/* Should generate a map with all exported items */ func TestAll(t *testing.T) { fs := mk_struct1() bcount := 0 fcount := 0 zcount := 0 athingp := 0 athing := 0 fmt.Fprintf(os.Stderr, "test: capture all fields in map\n") m := transform.Struct_to_map(fs, "_") // should capture all fields for k, _ := range m { //fmt.Fprintf( os.Stderr, "k=(%s) v=(%s)\n", k, v ) if strings.Index(k, "Foo") == 0 { fcount++ } else { if strings.Index(k, "Bar") == 0 { bcount++ } else { if strings.Index(k, "Baz") == 0 { zcount++ } else { if strings.Index(k, "Athingp") == 0 { athingp++ } else { if strings.Index(k, "Athing") == 0 { athing++ } } } } } } expect_fcount := 12 + 30 // two additional fields captured in foo space when doing all expect_bcount := 10 expect_zcount := 2 expect_acount := 2 expect_apcount := 2 if fcount != expect_fcount || bcount != expect_bcount || zcount != expect_zcount || athing != expect_acount || athingp != expect_apcount { fmt.Fprintf(os.Stderr, "all test: unexpected count, expected %d/%d/%d/%d/%d got %d/%d/%d/%d/%d\n", expect_fcount, expect_bcount, expect_zcount, expect_acount, expect_apcount, fcount, bcount, zcount, athingp, athing) for k, v := range m { fmt.Fprintf(os.Stderr, "m[%s] = (%s)\n", k, v) } t.Fail() } }
/* Should generate a map with only bar tagged items */ func TestBarOnly(t *testing.T) { fmt.Fprintf(os.Stderr, "test: capture only bar fields\n") count := 0 acount := 0 apcount := 0 fs := mk_struct1() m := transform.Struct_to_map(fs, "Bar") // should only generate bar elements into map for k, v := range m { //fmt.Fprintf( os.Stderr, "checking bar: %s = (%s)\n", k, v ) //uncomment to dump as we check things if strings.Index(k, "Bar") != 0 { if strings.Index(k, "Athingp/Bar_") != 0 { if strings.Index(k, "Athing/Bar_") != 0 { fmt.Fprintf(os.Stderr, "BAD: unexpected key found in 'bar' map: %s (%v)\n", k, v) t.Fail() } else { acount++ } } else { apcount++ } } else { //fmt.Printf( "bar: %s = %s\n", k, v ) count++ } } expect_count := 10 + 0 // top level + no array things for bar expect_apcount := 0 // pointer to thing struct elements (athing and athingp) expect_acount := 1 // direct struct thing elements if count != expect_count || apcount != expect_apcount || acount != expect_acount { // should only find the athing pointer referenced thing fmt.Fprintf(os.Stderr, "didn't find right number of elements in bar map, expected %d Foo_, %d apointer things, and %d athings; found bar=%d apthing=%d athing=%d\n", expect_count, expect_apcount, expect_acount, count, apcount, acount) for k, v := range m { fmt.Fprintf(os.Stderr, "m[%s] = (%s)\n", k, v) } } }
/* Should generate a map with only foo tagged items */ func TestFooOnly(t *testing.T) { fs := mk_struct1() count := 0 acount := 0 apcount := 0 fmt.Fprintf(os.Stderr, "test: capture only foo fields\n") m := transform.Struct_to_map(fs, "Foo") // should only generate foo elements into map for k, v := range m { fmt.Fprintf(os.Stderr, "checking foo: %s (%v)\n", k, v) // uncomment to dump the map if strings.Index(k, "Foo") != 0 { // count things; see struct and build function for expected counts if strings.Index(k, "Athingp/Foo_") != 0 { if strings.Index(k, "Athing/Foo_") != 0 { fmt.Fprintf(os.Stderr, "BAD: unexpected key found in 'foo' map: %s (%v)\n", k, v) // all fields should start with Foo_ or Athingp/Foo_ t.Fail() } else { acount++ } } else { apcount++ } } else { count++ } } expect_count := 12 + 28 // top level + array and map elements (don't forget cap and len elements for each array) expect_apcount := 1 // pointer to thing struct elements (athing and athingp) expect_acount := 0 // direct struct thing elements if count != expect_count || apcount != expect_apcount || acount != expect_acount { // should only find the athing pointer referenced thing fmt.Fprintf(os.Stderr, "didn't find right number of elements in foo map, expected %d Foo_, %d apointer things, and %d athings; found foo=%d apthing=%d athing=%d\n", expect_count, expect_apcount, expect_acount, count, apcount, acount) for k, v := range m { fmt.Fprintf(os.Stderr, "m[%s] = (%s)\n", k, v) } } }
/* Generate a map, and then use it to populate an empty struct. */ func TestPopulate(t *testing.T) { fmt.Fprintf(os.Stderr, "test: populate struct from map\n") ofs := mk_struct1() // make original struct fm := transform.Struct_to_map(ofs, "Foo") // generate foo map nfs := &Foo_bar{} // empty strut to populate if ofs.Foo_AJ1 == nfs.Foo_AJ1 { // spot check to ensure that the struct to fill is really 'empty' fmt.Fprintf(os.Stderr, "FAIL: old foo_aj1 matches new before transform: (%d) != (%d)\n", ofs.Foo_AJ1, nfs.Foo_AJ1) t.Fail() } if nfs.Athingp != nil { fmt.Fprintf(os.Stderr, "FAIL: athing in new object is not nil before transform\n") t.Fail() } transform.Map_to_struct(fm, nfs, "Foo") // fill it in just basedon foo tags if nfs.Athingp == nil { fmt.Fprintf(os.Stderr, "FAIL: athing in new object is sitll nil after transform\n") t.Fail() } if ofs.Athingp.Foo_thing_s != nfs.Athingp.Foo_thing_s { fmt.Fprintf(os.Stderr, "FAIL: old athingp.foo_thing_s did not match new: (%s) != (%s)\n", ofs.Athingp.Foo_thing_s, nfs.Athingp.Foo_thing_s) t.Fail() } if ofs.Athing.Foo_thing_s == nfs.Athing.Foo_thing_s { // athing isn't foo tagged, so these should NOT match fmt.Fprintf(os.Stderr, "FAIL: old athing.foo_thing_s DID match new and shouldn't: (%s) != (%s)\n", ofs.Athing.Foo_thing_s, nfs.Athing.Foo_thing_s) t.Fail() } if ofs.Foo_AJ1 != nfs.Foo_AJ1 { fmt.Fprintf(os.Stderr, "FAIL: old foo_aj1 did not match new: (%d) != (%d)\n", ofs.Foo_AJ1, nfs.Foo_AJ1) t.Fail() } if ofs.Foo_AJ2 != nfs.Foo_AJ2 { fmt.Fprintf(os.Stderr, "FAIL: old foo_aj1 did not match new: (%d) != (%d)\n", ofs.Foo_AJ2, nfs.Foo_AJ2) t.Fail() } if ofs.Foo_AJ3 != nfs.Foo_AJ3 { fmt.Fprintf(os.Stderr, "FAIL: old foo_aj1 did not match new: (%d) != (%d)\n", ofs.Foo_AJ3, nfs.Foo_AJ3) t.Fail() } if ofs.Foo_str != nfs.Foo_str { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%s) != (%s)\n", ofs.Foo_str, nfs.Foo_str) t.Fail() } if ofs.Foo_int != nfs.Foo_int { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", ofs.Foo_int, nfs.Foo_int) t.Fail() } if *ofs.Foo_intp1 != *nfs.Foo_intp1 { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", *ofs.Foo_intp1, *nfs.Foo_intp1) t.Fail() } if ofs.Foo_intp1 == nfs.Foo_intp1 { // pointers should NOT be the same fmt.Fprintf(os.Stderr, "FAIL: old and new intp1 pointers are the same and shouldn't be!\n") t.Fail() } if *ofs.Foo_intp2 != *nfs.Foo_intp2 { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", *ofs.Foo_intp2, *nfs.Foo_intp2) t.Fail() } if ofs.Foo_uint != nfs.Foo_uint { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", ofs.Foo_uint, nfs.Foo_uint) t.Fail() } if *ofs.Foo_uintp1 != *nfs.Foo_uintp1 { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", *ofs.Foo_uintp1, *nfs.Foo_uintp1) t.Fail() } if *ofs.Foo_uintp2 != *nfs.Foo_uintp2 { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%d) != (%d)\n", *ofs.Foo_uintp2, *nfs.Foo_uintp2) t.Fail() } if ofs.Foo_bool != nfs.Foo_bool { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%v) != (%v)\n", ofs.Foo_bool, nfs.Foo_bool) t.Fail() } if *ofs.Foo_boolp != *nfs.Foo_boolp { fmt.Fprintf(os.Stderr, "FAIL: old foo_str did not match new: (%v) != (%v)\n", *ofs.Foo_boolp, *nfs.Foo_boolp) t.Fail() } // ---------- validate contents of arrays ----------------------------- if !array_ck(ofs.Foo_array, nfs.Foo_array, "foo_array") { t.Fail() } if !array_ck(ofs.Foo_arrayp, nfs.Foo_arrayp, "foo_array") { t.Fail() } // ---------- validate contents of maps -------------------------------- if !imap_ck(ofs.Foo_mapi, nfs.Foo_mapi) { fmt.Fprintf(os.Stderr, "map foo_mapi doesn't validate; see above messages\n") t.Fail() } if !tmap_ck(ofs.Foo_mapp, nfs.Foo_mapp) { fmt.Fprintf(os.Stderr, "map foo_mapp doesn't validate; see above messages\n") t.Fail() } }