feat(eds): Flattened, FlattenedODS, Equals

codec_test.go

@@ -90,3 +90,30 @@ func generateMissingData(count int, codec Codec) [][]byte {
 
  return output
 }
+
+// testCodec is a codec that is used for testing purposes.
+type testCodec struct{}
+
+func newTestCodec() Codec {
+ return &testCodec{}
+}
+
+func (c *testCodec) Encode(chunk [][]byte) ([][]byte, error) {
+ return chunk, nil
+}
+
+func (c *testCodec) Decode(chunk [][]byte) ([][]byte, error) {
+ return chunk, nil
+}
+
+func (c *testCodec) MaxChunks() int {
+ return 0
+}
+
+func (c *testCodec) Name() string {
+ return "testCodec"
+}
+
+func (c *testCodec) ValidateChunkSize(_ int) error {
+ return nil
+}

extendeddatasquare.go

@@ -116,7 +116,7 @@
  }
  err = codec.ValidateChunkSize(int(chunkSize))
  if err != nil {
  return nil, err
  }
 
  data := make([][]byte, edsWidth*edsWidth)
@@ -274,6 +274,52 @@
  return eds.width
 }
 
+// FlattenedEDS returns the extended data square as a flattened slice of bytes.
+func (eds *ExtendedDataSquare) FlattenedEDS() [][]byte {
+ return eds.Flattened()
+}
+
+// FlattenedODS returns the original data square as a flattened slice of bytes.
+func (eds *ExtendedDataSquare) FlattenedODS() (flattened [][]byte) {
+ flattened = make([][]byte, eds.originalDataWidth*eds.originalDataWidth)
+ for i := uint(0); i < eds.originalDataWidth; i++ {
+ row := eds.Row(i)
+ for j := uint(0); j < eds.originalDataWidth; j++ {
+ flattened[(i*eds.originalDataWidth)+j] = row[j]
+ }
+ }
+ return flattened
+}
+
+// Equals returns true if other is equal to eds.
+func (eds *ExtendedDataSquare) Equals(other *ExtendedDataSquare) bool {
+ if eds.originalDataWidth != other.originalDataWidth {
+ return false
+ }
+ if eds.codec.Name() != other.codec.Name() {
+ return false
+ }
+ if eds.chunkSize != other.chunkSize {
+ return false
+ }
+ if eds.width != other.width {
+ return false
+ }
+
+ for rowIndex := uint(0); rowIndex < eds.Width(); rowIndex++ {
+ edsRow := eds.Row(rowIndex)
+ otherRow := other.Row(rowIndex)
+
+ for colIndex := 0; colIndex < len(edsRow); colIndex++ {
+ if !bytes.Equal(edsRow[colIndex], otherRow[colIndex]) {
+ return false
+ }
+ }
+ }
+
+ return true
+}
+
 // validateEdsWidth returns an error if edsWidth is not a valid width for an
 // extended data square.
 func validateEdsWidth(edsWidth uint) error {

extendeddatasquare_test.go

@@ -74,7 +74,7 @@ func TestComputeExtendedDataSquare(t *testing.T) {
 
 func TestImportExtendedDataSquare(t *testing.T) {
  t.Run("is able to import an EDS", func(t *testing.T) {
- eds := createExampleEds(t, ShardSize)
+ eds := createExampleEds(t, shareSize)
  got, err := ImportExtendedDataSquare(eds.Flattened(), NewLeoRSCodec(), NewDefaultTree)
  assert.NoError(t, err)
  assert.Equal(t, eds.Flattened(), got.Flattened())
@@ -293,6 +293,82 @@ func genRandDS(width int, chunkSize int) [][]byte {
  return ds
 }
 
+func TestFlattenedEDS(t *testing.T) {
+ example := createExampleEds(t, shareSize)
+ want := [][]byte{
+ ones, twos, zeros, threes,
+ threes, fours, eights, fifteens,
+ twos, elevens, thirteens, fours,
+ zeros, thirteens, fives, eights,
+ }
+
+ got := example.FlattenedEDS()
+ assert.Equal(t, want, got)
+}
+
+func TestFlattenedODS(t *testing.T) {
+ example := createExampleEds(t, shareSize)
+ want := [][]byte{
+ ones, twos,
+ threes, fours,
+ }
+
+ got := example.FlattenedODS()
+ assert.Equal(t, want, got)
+}
+
+func TestEquals(t *testing.T) {
+ t.Run("returns true for two equal EDS", func(t *testing.T) {
+ a := createExampleEds(t, shareSize)
+ b := createExampleEds(t, shareSize)
+ assert.True(t, a.Equals(b))
+ })
+ t.Run("returns false for two unequal EDS", func(t *testing.T) {
+ a := createExampleEds(t, shareSize)
+
+ type testCase struct {
+ name string
+ other *ExtendedDataSquare
+ }
+
+ unequalOriginalDataWidth := createExampleEds(t, shareSize)
+ unequalOriginalDataWidth.originalDataWidth = 1
+
+ unequalCodecs := createExampleEds(t, shareSize)
+ unequalCodecs.codec = newTestCodec()
+
+ unequalChunkSize := createExampleEds(t, shareSize*2)
+
+ unequalEds, err := ComputeExtendedDataSquare([][]byte{ones}, NewLeoRSCodec(), NewDefaultTree)
+ require.NoError(t, err)
+
+ testCases := []testCase{
+ {
+ name: "unequal original data width",
+ other: unequalOriginalDataWidth,
+ },
+ {
+ name: "unequal codecs",
+ other: unequalCodecs,
+ },
+ {
+ name: "unequal chunkSize",
+ other: unequalChunkSize,
+ },
+ {
+ name: "unequalEds",
+ other: unequalEds,
+ },
+ }
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ assert.False(t, a.Equals(tc.other))
+ assert.False(t, reflect.DeepEqual(a, tc.other))
+ })
+ }
+ })
+}
+
 func createExampleEds(t *testing.T, chunkSize int) (eds *ExtendedDataSquare) {
  ones := bytes.Repeat([]byte{1}, chunkSize)
  twos := bytes.Repeat([]byte{2}, chunkSize)