示例#1
0
func (s *testSuite) TestShove() {
	s.LdbFlagName = "-source-ldb"
	sn := "storeName"
	source1 := dataset.NewDataset(datas.NewDataStore(chunks.NewLevelDBStore(s.LdbDir, sn, 1, false)), "foo")
	source1, err := source1.Commit(types.Int32(42))
	s.NoError(err)
	source2, err := source1.Commit(types.Int32(43))
	s.NoError(err)
	source1HeadRef := source1.Head().Ref()
	source2.Store().Close() // Close DataStore backing both Datasets

	ldb2dir := path.Join(s.TempDir, "ldb2")
	out := s.Run(main, []string{"-source-store", sn, "-source", source1HeadRef.String(), "-sink-ldb", ldb2dir, "-sink-store", sn, "-sink-ds", "bar"})
	s.Equal("", out)

	dest := dataset.NewDataset(datas.NewDataStore(chunks.NewLevelDBStore(ldb2dir, sn, 1, false)), "bar")
	s.True(types.Int32(42).Equals(dest.Head().Value()))
	dest.Store().Close()

	out = s.Run(main, []string{"-source-store", sn, "-source", "foo", "-sink-ldb", ldb2dir, "-sink-ds", "bar"})
	s.Equal("", out)

	dest = dataset.NewDataset(datas.NewDataStore(chunks.NewLevelDBStore(ldb2dir, sn, 1, false)), "bar")
	s.True(types.Int32(43).Equals(dest.Head().Value()))
	dest.Store().Close()
}
示例#2
0
文件: walk_test.go 项目: arv/noms-old
func (suite *WalkAllTestSuite) TestWalkComposites() {
	suite.walkWorker(suite.storeAndRef(types.NewList()), 2)
	suite.walkWorker(suite.storeAndRef(types.NewList(types.Bool(false), types.Int32(8))), 4)
	suite.walkWorker(suite.storeAndRef(types.NewSet()), 2)
	suite.walkWorker(suite.storeAndRef(types.NewSet(types.Bool(false), types.Int32(8))), 4)
	suite.walkWorker(suite.storeAndRef(types.NewMap()), 2)
	suite.walkWorker(suite.storeAndRef(types.NewMap(types.Int32(8), types.Bool(true), types.Int32(0), types.Bool(false))), 6)
}
示例#3
0
func readerForQuarter(v types.Value) []types.Value {
	values := []types.Value{}
	s := v.(Quarter)
	values = append(values, types.Int32(s._Year))
	values = append(values, s._Quarter)
	return values
}
示例#4
0
文件: map_test.go 项目: arv/noms-old
func TestValueMapDef(t *testing.T) {
	assert := assert.New(t)

	def := gen.MapOfStringToValueDef{"s": types.NewString("s"), "i": types.Int32(42)}
	m := def.New()

	assert.Equal(uint64(2), m.Len())
	assert.True(types.NewString("s").Equals(m.Get("s")))
	assert.True(types.Int32(42).Equals(m.Get("i")))

	def2 := m.Def()
	assert.Equal(def, def2)

	m2 := gen.NewMapOfStringToValue().Set("s", types.NewString("s")).Set("i", types.Int32(42))
	assert.True(m.Equals(m2))
}
示例#5
0
文件: map_test.go 项目: arv/noms-old
func TestValueMapValue(t *testing.T) {
	assert := assert.New(t)

	def := gen.MapOfStringToValueDef{"s": types.NewString("s"), "i": types.Int32(42)}
	var m types.Value
	m = def.New()
	m2 := m.(gen.MapOfStringToValue)
	assert.True(m.Equals(m2))
}
示例#6
0
文件: pull_test.go 项目: arv/noms-old
func pullFirstCommit(t *testing.T, topdown bool) {
	assert := assert.New(t)

	sink := createTestDataset("sink")
	source := createTestDataset("source")

	sourceInitialValue := types.NewMap(
		types.NewString("first"), NewList(source),
		types.NewString("second"), NewList(source, types.Int32(2)))

	NewList(sink)
	NewList(sink, types.Int32(2))

	source, err := source.Commit(sourceInitialValue)
	assert.NoError(err)

	sink, err = sink.pull(source.Store(), source.Head().Ref(), 1, topdown)
	assert.NoError(err)
	assert.True(source.Head().Equals(sink.Head()))
}
示例#7
0
文件: walk_test.go 项目: arv/noms-old
func (suite *WalkAllTestSuite) TestWalkNestedComposites() {
	cs := chunks.NewMemoryStore()
	suite.walkWorker(suite.storeAndRef(types.NewList(suite.NewSet(cs), types.Int32(8))), 5)
	suite.walkWorker(suite.storeAndRef(types.NewSet(suite.NewList(cs), suite.NewSet(cs))), 6)
	// {"string": "string",
	//  "list": [false true],
	//  "map": {"nested": "string"}
	//  "mtlist": []
	//  "set": [5 7 8]
	//  []: "wow"
	// }
	nested := types.NewMap(
		types.NewString("string"), types.NewString("string"),
		types.NewString("list"), suite.NewList(cs, types.Bool(false), types.Bool(true)),
		types.NewString("map"), suite.NewMap(cs, types.NewString("nested"), types.NewString("string")),
		types.NewString("mtlist"), suite.NewList(cs),
		types.NewString("set"), suite.NewSet(cs, types.Int32(5), types.Int32(7), types.Int32(8)),
		suite.NewList(cs), types.NewString("wow"), // note that the dupe list chunk is skipped
	)
	suite.walkWorker(suite.storeAndRef(nested), 25)
}
示例#8
0
文件: schema.go 项目: arv/noms-old
// StringToType takes a piece of data as a string and attempts to convert it to a types.Value of the appropriate types.NomsKind.
func StringToType(s string, k types.NomsKind) types.Value {
	switch k {
	case types.Uint8Kind:
		ival, err := strconv.ParseUint(s, 10, 8)
		d.Chk.NoError(err)
		return types.Uint8(ival)
	case types.Uint16Kind:
		ival, err := strconv.ParseUint(s, 10, 16)
		d.Chk.NoError(err)
		return types.Uint16(ival)
	case types.Uint32Kind:
		ival, err := strconv.ParseUint(s, 10, 32)
		d.Chk.NoError(err)
		return types.Uint32(ival)
	case types.Uint64Kind:
		ival, err := strconv.ParseUint(s, 10, 64)
		d.Chk.NoError(err)
		return types.Uint64(ival)
	case types.Int8Kind:
		ival, err := strconv.ParseInt(s, 10, 8)
		d.Chk.NoError(err)
		return types.Int8(ival)
	case types.Int16Kind:
		ival, err := strconv.ParseInt(s, 10, 16)
		d.Chk.NoError(err)
		return types.Int16(ival)
	case types.Int32Kind:
		ival, err := strconv.ParseInt(s, 10, 32)
		d.Chk.NoError(err)
		return types.Int32(ival)
	case types.Int64Kind:
		ival, err := strconv.ParseInt(s, 10, 64)
		d.Chk.NoError(err)
		return types.Int64(ival)
	case types.Float32Kind:
		fval, err := strconv.ParseFloat(s, 32)
		d.Chk.NoError(err)
		return types.Float32(fval)
	case types.Float64Kind:
		fval, err := strconv.ParseFloat(s, 64)
		d.Chk.NoError(err)
		return types.Float64(fval)
	case types.BoolKind:
		bval, err := strconv.ParseBool(s)
		d.Chk.NoError(err)
		return types.Bool(bval)
	case types.StringKind:
		return types.NewString(s)
	default:
		d.Exp.Fail("Invalid column type kind:", k)
	}
	panic("not reached")
}
示例#9
0
文件: pull_test.go 项目: arv/noms-old
func pullTest(t *testing.T, topdown bool) {
	assert := assert.New(t)

	sink := createTestDataset("sink")
	source := createTestDataset("source")

	// Give sink and source some initial shared context.
	sourceInitialValue := types.NewMap(
		types.NewString("first"), NewList(source),
		types.NewString("second"), NewList(source, types.Int32(2)))
	sinkInitialValue := types.NewMap(
		types.NewString("first"), NewList(sink),
		types.NewString("second"), NewList(sink, types.Int32(2)))

	var err error
	source, err = source.Commit(sourceInitialValue)
	assert.NoError(err)
	sink, err = sink.Commit(sinkInitialValue)
	assert.NoError(err)

	// Add some new stuff to source.
	updatedValue := sourceInitialValue.Set(
		types.NewString("third"), NewList(source, types.Int32(3)))
	source, err = source.Commit(updatedValue)
	assert.NoError(err)

	// Add some more stuff, so that source isn't directly ahead of sink.
	updatedValue = updatedValue.Set(
		types.NewString("fourth"), NewList(source, types.Int32(4)))
	source, err = source.Commit(updatedValue)
	assert.NoError(err)

	sink, err = sink.pull(source.Store(), source.Head().Ref(), 1, topdown)
	assert.NoError(err)
	assert.True(source.Head().Equals(sink.Head()))
}
示例#10
0
func (s StructPrimitives) ChildValues() (ret []types.Value) {
	ret = append(ret, types.Uint64(s._uint64))
	ret = append(ret, types.Uint32(s._uint32))
	ret = append(ret, types.Uint16(s._uint16))
	ret = append(ret, types.Uint8(s._uint8))
	ret = append(ret, types.Int64(s._int64))
	ret = append(ret, types.Int32(s._int32))
	ret = append(ret, types.Int16(s._int16))
	ret = append(ret, types.Int8(s._int8))
	ret = append(ret, types.Float64(s._float64))
	ret = append(ret, types.Float32(s._float32))
	ret = append(ret, types.Bool(s._bool))
	ret = append(ret, types.NewString(s._string))
	ret = append(ret, s._blob)
	ret = append(ret, s._value)
	return
}
示例#11
0
func readerForStructPrimitives(v types.Value) []types.Value {
	values := []types.Value{}
	s := v.(StructPrimitives)
	values = append(values, types.Uint64(s._uint64))
	values = append(values, types.Uint32(s._uint32))
	values = append(values, types.Uint16(s._uint16))
	values = append(values, types.Uint8(s._uint8))
	values = append(values, types.Int64(s._int64))
	values = append(values, types.Int32(s._int32))
	values = append(values, types.Int16(s._int16))
	values = append(values, types.Int8(s._int8))
	values = append(values, types.Float64(s._float64))
	values = append(values, types.Float32(s._float32))
	values = append(values, types.Bool(s._bool))
	values = append(values, types.NewString(s._string))
	values = append(values, s._blob)
	values = append(values, s._value)
	return values
}
示例#12
0
func (def KeyDef) SetYear(val int32) KeyDef {
	def.__unionIndex = 4
	def.__unionValue = types.Int32(val)
	return def
}
示例#13
0
func (s Key) SetYear(val int32) Key {
	s.__unionIndex = 4
	s.__unionValue = types.Int32(val)
	s.ref = &ref.Ref{}
	return s
}
示例#14
0
func (s Quarter) ChildValues() (ret []types.Value) {
	ret = append(ret, types.Int32(s._Year))
	ret = append(ret, s._Quarter)
	return
}