func TestRead(t *testing.T) {
assert := assert.New(t)
ds := datas.NewDataStore(chunks.NewMemoryStore())
dataString := `a,1,true
b,2,false
`
r := NewCSVReader(bytes.NewBufferString(dataString), ',')
headers := []string{"A", "B", "C"}
kinds := KindSlice{types.StringKind, types.Int8Kind, types.BoolKind}
l, typeRef, typeDef := Read(r, "test", headers, kinds, ds)
assert.Equal(uint64(2), l.Len())
assert.True(typeRef.IsUnresolved())
desc, ok := typeDef.Desc.(types.StructDesc)
assert.True(ok)
assert.Len(desc.Fields, 3)
assert.Equal("A", desc.Fields[0].Name)
assert.Equal("B", desc.Fields[1].Name)
assert.Equal("C", desc.Fields[2].Name)
assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.NewString("a")))
assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.NewString("b")))
assert.True(l.Get(0).(types.Struct).Get("B").Equals(types.Int8(1)))
assert.True(l.Get(1).(types.Struct).Get("B").Equals(types.Int8(2)))
assert.True(l.Get(0).(types.Struct).Get("C").Equals(types.Bool(true)))
assert.True(l.Get(1).(types.Struct).Get("C").Equals(types.Bool(false)))
}
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)
}
func readerForOptionalStruct(v types.Value) []types.Value {
values := []types.Value{}
s := v.(OptionalStruct)
values = append(values, types.Bool(s.__optionals))
if s.__optionals {
values = append(values, types.NewString(s._s))
}
values = append(values, types.Bool(s.__optionalb))
if s.__optionalb {
values = append(values, types.Bool(s._b))
}
return values
}
func TestReadWriteCache(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
ds := NewDataStore(cs)
var v types.Value = types.Bool(true)
assert.NotEqual(ref.Ref{}, ds.WriteValue(v))
assert.Equal(1, cs.Writes)
r := ds.WriteValue(v).TargetRef()
assert.Equal(1, cs.Writes)
v = ds.ReadValue(r)
assert.True(v.Equals(types.Bool(true)))
}
func (m MapOfBoolToString) MaybeGet(p bool) (string, bool) {
v, ok := m.m.MaybeGet(types.Bool(p))
if !ok {
return "", false
}
return v.(types.String).String(), ok
}
func (s SetOfBool) fromElemSlice(p []bool) []types.Value {
r := make([]types.Value, len(p))
for i, v := range p {
r[i] = types.Bool(v)
}
return r
}
func (m MapOfStringToValue) MaybeGet(p string) (types.Value, bool) {
v, ok := m.m.MaybeGet(types.NewString(p))
if !ok {
return types.Bool(false), false
}
return v, ok
}
func (s StructWithList) ChildValues() (ret []types.Value) {
ret = append(ret, s._l)
ret = append(ret, types.Bool(s._b))
ret = append(ret, types.NewString(s._s))
ret = append(ret, types.Int64(s._i))
return
}
func (def MapOfBoolToStringDef) New() MapOfBoolToString {
kv := make([]types.Value, 0, len(def)*2)
for k, v := range def {
kv = append(kv, types.Bool(k), types.NewString(v))
}
return MapOfBoolToString{types.NewTypedMap(__typeForMapOfBoolToString, kv...), &ref.Ref{}}
}
func TestWriteRefToNonexistentValue(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
ds := NewDataStore(cs)
assert.Panics(func() { ds.WriteValue(types.NewRef(types.Bool(true).Ref())) })
}
func readerForS(v types.Value) []types.Value {
values := []types.Value{}
s := v.(S)
values = append(values, types.NewString(s._s))
values = append(values, types.Bool(s._b))
return values
}
func NewCommit() Commit {
return Commit{
_value: types.Bool(false),
_parents: NewSetOfRefOfCommit(),
ref: &ref.Ref{},
}
}
func (s OptionalStruct) ChildValues() (ret []types.Value) {
if s.__optionals {
ret = append(ret, types.NewString(s._s))
}
if s.__optionalb {
ret = append(ret, types.Bool(s._b))
}
return
}
func readerForStructWithList(v types.Value) []types.Value {
values := []types.Value{}
s := v.(StructWithList)
values = append(values, s._l)
values = append(values, types.Bool(s._b))
values = append(values, types.NewString(s._s))
values = append(values, types.Int64(s._i))
return values
}
func (def SetOfBoolDef) New() SetOfBool {
l := make([]types.Value, len(def))
i := 0
for d, _ := range def {
l[i] = types.Bool(d)
i++
}
return SetOfBool{types.NewTypedSet(__typeForSetOfBool, l...), &ref.Ref{}}
}
func TestWriteValueTypeRef(t *testing.T) {
assert := assert.New(t)
cs := chunks.NewTestStore()
ds := NewDataStore(cs)
b := types.Bool(true)
assert.NotEqual(ref.Ref{}, ds.WriteValue(b))
assert.NotPanics(func() { ds.WriteValue(types.NewRef(b.Ref())) })
}
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)
}
// 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")
}
func (suite *LibTestSuite) TestCompositeTypes() {
// [false true]
suite.EqualValues(
types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
NomsValueFromDecodedJSON([]interface{}{false, true}))
// [[false true]]
suite.EqualValues(
types.NewList().Append(
types.NewList().Append(types.Bool(false)).Append(types.Bool(true))),
NomsValueFromDecodedJSON([]interface{}{[]interface{}{false, true}}))
// {"string": "string",
// "list": [false true],
// "map": {"nested": "string"}
// }
m := MapOfStringToValueDef{
"string": types.NewString("string"),
"list": types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
"map": MapOfStringToValueDef{"nested": types.NewString("string")}.New(),
}.New()
o := NomsValueFromDecodedJSON(map[string]interface{}{
"string": "string",
"list": []interface{}{false, true},
"map": map[string]interface{}{"nested": "string"},
})
suite.True(m.Equals(o))
}
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
}
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
}
func NewStructPrimitives() StructPrimitives {
return StructPrimitives{
_uint64: uint64(0),
_uint32: uint32(0),
_uint16: uint16(0),
_uint8: uint8(0),
_int64: int64(0),
_int32: int32(0),
_int16: int16(0),
_int8: int8(0),
_float64: float64(0),
_float32: float32(0),
_bool: false,
_string: "",
_blob: types.NewEmptyBlob(),
_value: types.Bool(false),
ref: &ref.Ref{},
}
}
func (m MapOfBoolToString) Set(k bool, v string) MapOfBoolToString {
return MapOfBoolToString{m.m.Set(types.Bool(k), types.NewString(v)), &ref.Ref{}}
}
func (m MapOfBoolToString) Has(p bool) bool {
return m.m.Has(types.Bool(p))
}
func (m MapOfBoolToString) Remove(p bool) MapOfBoolToString {
return MapOfBoolToString{m.m.Remove(types.Bool(p)), &ref.Ref{}}
}
func (suite *LibTestSuite) TestPrimitiveTypes() {
suite.EqualValues(types.NewString("expected"), NomsValueFromDecodedJSON("expected"))
suite.EqualValues(types.Bool(false), NomsValueFromDecodedJSON(false))
suite.EqualValues(types.Float64(1.7), NomsValueFromDecodedJSON(1.7))
suite.False(NomsValueFromDecodedJSON(1.7).Equals(types.Bool(true)))
}
func (m MapOfBoolToString) Get(p bool) string {
return m.m.Get(types.Bool(p)).(types.String).String()
}
func (s S) ChildValues() (ret []types.Value) {
ret = append(ret, types.NewString(s._s))
ret = append(ret, types.Bool(s._b))
return
}
func (s SetOfBool) Has(p bool) bool {
return s.s.Has(types.Bool(p))
}
func TestValidateRef(t *testing.T) {
ds := createTestDataset("test")
r := ds.Store().WriteValue(types.Bool(true)).TargetRef()
assert.Panics(t, func() { ds.validateRefAsCommit(r) })
}
