func TestDirBuilder(t *testing.T) { dserv := testu.GetDAGServ() ctx, closer := context.WithCancel(context.Background()) defer closer() inbuf, node := testu.GetRandomNode(t, dserv, 1024) key := node.Cid() b := NewDirectory(dserv) b.AddChild(ctx, "random", key) dir := b.GetNode() outn, err := dir.GetLinkedProtoNode(ctx, dserv, "random") if err != nil { t.Fatal(err) } reader, err := NewDagReader(ctx, outn, dserv) if err != nil { t.Fatal(err) } outbuf, err := ioutil.ReadAll(reader) if err != nil { t.Fatal(err) } err = testu.ArrComp(inbuf, outbuf) if err != nil { t.Fatal(err) } }
func TestCtxRead(t *testing.T) { dserv := testu.GetDAGServ() n := testu.GetEmptyNode(t, dserv) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } _, err = dagmod.Write([]byte{0, 1, 2, 3, 4, 5, 6, 7}) if err != nil { t.Fatal(err) } dagmod.Seek(0, os.SEEK_SET) readBuf := make([]byte, 4) _, err = dagmod.CtxReadFull(ctx, readBuf) if err != nil { t.Fatal(err) } err = testu.ArrComp(readBuf, []byte{0, 1, 2, 3}) if err != nil { t.Fatal(err) } // TODO(Kubuxu): context cancel case, I will do it after I figure out dagreader tests, // because this is exacelly the same. }
func TestMultiWrite(t *testing.T) { dserv := testu.GetDAGServ() n := testu.GetEmptyNode(t, dserv) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } data := make([]byte, 4000) u.NewTimeSeededRand().Read(data) for i := 0; i < len(data); i++ { n, err := dagmod.WriteAt(data[i:i+1], int64(i)) if err != nil { t.Fatal(err) } if n != 1 { t.Fatal("Somehow wrote the wrong number of bytes! (n != 1)") } size, err := dagmod.Size() if err != nil { t.Fatal(err) } if size != int64(i+1) { t.Fatal("Size was reported incorrectly") } } nd, err := dagmod.GetNode() if err != nil { t.Fatal(err) } read, err := uio.NewDagReader(context.Background(), nd, dserv) if err != nil { t.Fatal(err) } rbuf, err := ioutil.ReadAll(read) if err != nil { t.Fatal(err) } err = testu.ArrComp(rbuf, data) if err != nil { t.Fatal(err) } }
func TestSeekPastEndWrite(t *testing.T) { dserv := testu.GetDAGServ() n := testu.GetEmptyNode(t, dserv) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } buf := make([]byte, 5000) u.NewTimeSeededRand().Read(buf[2500:]) nseek, err := dagmod.Seek(2500, os.SEEK_SET) if err != nil { t.Fatal(err) } if nseek != 2500 { t.Fatal("failed to seek") } wrote, err := dagmod.Write(buf[2500:]) if err != nil { t.Fatal(err) } if wrote != 2500 { t.Fatal("incorrect write amount") } _, err = dagmod.Seek(0, os.SEEK_SET) if err != nil { t.Fatal(err) } out, err := ioutil.ReadAll(dagmod) if err != nil { t.Fatal(err) } if err = testu.ArrComp(out, buf); err != nil { t.Fatal(err) } }
func testModWrite(t *testing.T, beg, size uint64, orig []byte, dm *DagModifier) []byte { newdata := make([]byte, size) r := u.NewTimeSeededRand() r.Read(newdata) if size+beg > uint64(len(orig)) { orig = append(orig, make([]byte, (size+beg)-uint64(len(orig)))...) } copy(orig[beg:], newdata) nmod, err := dm.WriteAt(newdata, int64(beg)) if err != nil { t.Fatal(err) } if nmod != int(size) { t.Fatalf("Mod length not correct! %d != %d", nmod, size) } nd, err := dm.GetNode() if err != nil { t.Fatal(err) } err = trickle.VerifyTrickleDagStructure(nd, dm.dagserv, h.DefaultLinksPerBlock, 4) if err != nil { t.Fatal(err) } rd, err := uio.NewDagReader(context.Background(), nd, dm.dagserv) if err != nil { t.Fatal(err) } after, err := ioutil.ReadAll(rd) if err != nil { t.Fatal(err) } err = testu.ArrComp(after, orig) if err != nil { t.Fatal(err) } return orig }
func TestWriteNewFile(t *testing.T) { dserv := testu.GetDAGServ() n := testu.GetEmptyNode(t, dserv) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } towrite := make([]byte, 2000) u.NewTimeSeededRand().Read(towrite) nw, err := dagmod.Write(towrite) if err != nil { t.Fatal(err) } if nw != len(towrite) { t.Fatal("Wrote wrong amount") } nd, err := dagmod.GetNode() if err != nil { t.Fatal(err) } read, err := uio.NewDagReader(ctx, nd, dserv) if err != nil { t.Fatal(err) } data, err := ioutil.ReadAll(read) if err != nil { t.Fatal(err) } if err := testu.ArrComp(data, towrite); err != nil { t.Fatal(err) } }
func TestWriteTo(t *testing.T) { dserv := testu.GetDAGServ() inbuf, node := testu.GetRandomNode(t, dserv, 1024) ctx, closer := context.WithCancel(context.Background()) defer closer() reader, err := NewDagReader(ctx, node, dserv) if err != nil { t.Fatal(err) } outbuf := new(bytes.Buffer) reader.WriteTo(outbuf) err = testu.ArrComp(inbuf, outbuf.Bytes()) if err != nil { t.Fatal(err) } }
func TestBasicRead(t *testing.T) { dserv := testu.GetDAGServ() inbuf, node := testu.GetRandomNode(t, dserv, 1024) ctx, closer := context.WithCancel(context.Background()) defer closer() reader, err := NewDagReader(ctx, node, dserv) if err != nil { t.Fatal(err) } outbuf, err := ioutil.ReadAll(reader) if err != nil { t.Fatal(err) } err = testu.ArrComp(inbuf, outbuf) if err != nil { t.Fatal(err) } }
func TestMetadataNode(t *testing.T) { dserv := testu.GetDAGServ() rdata, rnode := testu.GetRandomNode(t, dserv, 512) _, err := dserv.Add(rnode) if err != nil { t.Fatal(err) } ctx, closer := context.WithCancel(context.Background()) defer closer() data, err := unixfs.BytesForMetadata(&unixfs.Metadata{"text", 125}) if err != nil { t.Fatal(err) } node := mdag.NodeWithData(data) _, err = NewDagReader(ctx, node, dserv) if err == nil { t.Fatal("expected an error") } if !strings.Contains(err.Error(), "incorrectly formatted") { t.Fatal("expected different error") } node.AddNodeLink("", rnode) reader, err := NewDagReader(ctx, node, dserv) if err != nil { t.Fatal(err) } readdata, err := ioutil.ReadAll(reader) if err != nil { t.Fatal(err) } if err := testu.ArrComp(rdata, readdata); err != nil { t.Fatal(err) } }
func TestLargeWriteChunks(t *testing.T) { dserv := testu.GetDAGServ() n := testu.GetEmptyNode(t, dserv) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } wrsize := 1000 datasize := 10000000 data := make([]byte, datasize) u.NewTimeSeededRand().Read(data) for i := 0; i < datasize/wrsize; i++ { n, err := dagmod.WriteAt(data[i*wrsize:(i+1)*wrsize], int64(i*wrsize)) if err != nil { t.Fatal(err) } if n != wrsize { t.Fatal("failed to write buffer") } } out, err := ioutil.ReadAll(dagmod) if err != nil { t.Fatal(err) } if err = testu.ArrComp(out, data); err != nil { t.Fatal(err) } }
func TestDagTruncate(t *testing.T) { dserv := testu.GetDAGServ() b, n := testu.GetRandomNode(t, dserv, 50000) ctx, cancel := context.WithCancel(context.Background()) defer cancel() dagmod, err := NewDagModifier(ctx, n, dserv, testu.SizeSplitterGen(512)) if err != nil { t.Fatal(err) } err = dagmod.Truncate(12345) if err != nil { t.Fatal(err) } size, err := dagmod.Size() if err != nil { t.Fatal(err) } if size != 12345 { t.Fatal("size was incorrect!") } _, err = dagmod.Seek(0, os.SEEK_SET) if err != nil { t.Fatal(err) } out, err := ioutil.ReadAll(dagmod) if err != nil { t.Fatal(err) } if err = testu.ArrComp(out, b[:12345]); err != nil { t.Fatal(err) } err = dagmod.Truncate(10) if err != nil { t.Fatal(err) } size, err = dagmod.Size() if err != nil { t.Fatal(err) } if size != 10 { t.Fatal("size was incorrect!") } err = dagmod.Truncate(0) if err != nil { t.Fatal(err) } size, err = dagmod.Size() if err != nil { t.Fatal(err) } if size != 0 { t.Fatal("size was incorrect!") } }