func (suite *TimesTimeArithSuite) TestCases() { suite.T().Log("Running TimesTimeArithSuite: Test basic time arithmetic") // times/time_arith.yaml line #3 // rt1 = 1375147296.681 suite.T().Log("Possibly executing: var rt1 float64 = 1375147296.681") rt1 := 1375147296.681 _ = rt1 // Prevent any noused variable errors // times/time_arith.yaml line #4 // rt2 = 1375147296.682 suite.T().Log("Possibly executing: var rt2 float64 = 1375147296.682") rt2 := 1375147296.682 _ = rt2 // Prevent any noused variable errors // times/time_arith.yaml line #5 // rt3 = 1375147297.681 suite.T().Log("Possibly executing: var rt3 float64 = 1375147297.681") rt3 := 1375147297.681 _ = rt3 // Prevent any noused variable errors // times/time_arith.yaml line #6 // rt4 = 2375147296.681 suite.T().Log("Possibly executing: var rt4 float64 = 2375147296.681") rt4 := 2375147296.681 _ = rt4 // Prevent any noused variable errors // times/time_arith.yaml line #7 // rts = [rt1, rt2, rt3, rt4] suite.T().Log("Possibly executing: var rts []interface{} = []interface{}{rt1, rt2, rt3, rt4}") rts := []interface{}{rt1, rt2, rt3, rt4} _ = rts // Prevent any noused variable errors // times/time_arith.yaml line #9 // t1 = r.epoch_time(rt1) suite.T().Log("Possibly executing: var t1 r.Term = r.EpochTime(rt1)") t1 := r.EpochTime(rt1) _ = t1 // Prevent any noused variable errors // times/time_arith.yaml line #10 // t2 = r.epoch_time(rt2) suite.T().Log("Possibly executing: var t2 r.Term = r.EpochTime(rt2)") t2 := r.EpochTime(rt2) _ = t2 // Prevent any noused variable errors // times/time_arith.yaml line #11 // t3 = r.epoch_time(rt3) suite.T().Log("Possibly executing: var t3 r.Term = r.EpochTime(rt3)") t3 := r.EpochTime(rt3) _ = t3 // Prevent any noused variable errors // times/time_arith.yaml line #12 // t4 = r.epoch_time(rt4) suite.T().Log("Possibly executing: var t4 r.Term = r.EpochTime(rt4)") t4 := r.EpochTime(rt4) _ = t4 // Prevent any noused variable errors // times/time_arith.yaml line #13 // ts = r.expr([t1, t2, t3, t4]) suite.T().Log("Possibly executing: var ts r.Term = r.Expr([]interface{}{t1, t2, t3, t4})") ts := r.Expr([]interface{}{t1, t2, t3, t4}) _ = ts // Prevent any noused variable errors { // times/time_arith.yaml line #17 /* true */ var expected_ bool = true /* ((t2 - t1) * 1000).do(lambda x:(x > 0.99) & (x < 1.01)) */ suite.T().Log("About to run line #17: r.Sub(t2, t1).Mul(1000).Do(func(x r.Term) interface{} { return r.Gt(x, 0.99).And(r.Lt(x, 1.01))})") runAndAssert(suite.Suite, expected_, r.Sub(t2, t1).Mul(1000).Do(func(x r.Term) interface{} { return r.Gt(x, 0.99).And(r.Lt(x, 1.01)) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #17") } { // times/time_arith.yaml line #20 /* 1 */ var expected_ int = 1 /* t3 - t1 */ suite.T().Log("About to run line #20: r.Sub(t3, t1)") runAndAssert(suite.Suite, expected_, r.Sub(t3, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #20") } { // times/time_arith.yaml line #23 /* 1000000000 */ var expected_ int = 1000000000 /* t4 - t1 */ suite.T().Log("About to run line #23: r.Sub(t4, t1)") runAndAssert(suite.Suite, expected_, r.Sub(t4, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #23") } { // times/time_arith.yaml line #28 /* true */ var expected_ bool = true /* ((t1 - t2) * 1000).do(lambda x:(x < -0.99) & (x > -1.01)) */ suite.T().Log("About to run line #28: r.Sub(t1, t2).Mul(1000).Do(func(x r.Term) interface{} { return r.Lt(x, -0.99).And(r.Gt(x, -1.01))})") runAndAssert(suite.Suite, expected_, r.Sub(t1, t2).Mul(1000).Do(func(x r.Term) interface{} { return r.Lt(x, -0.99).And(r.Gt(x, -1.01)) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #28") } { // times/time_arith.yaml line #31 /* -1 */ var expected_ int = -1 /* t1 - t3 */ suite.T().Log("About to run line #31: r.Sub(t1, t3)") runAndAssert(suite.Suite, expected_, r.Sub(t1, t3), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #31") } { // times/time_arith.yaml line #34 /* -1000000000 */ var expected_ int = -1000000000 /* t1 - t4 */ suite.T().Log("About to run line #34: r.Sub(t1, t4)") runAndAssert(suite.Suite, expected_, r.Sub(t1, t4), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #34") } { // times/time_arith.yaml line #39 /* ([rt1, rt2, rt3, rt4]) */ var expected_ []interface{} = []interface{}{rt1, rt2, rt3, rt4} /* ts.map(lambda x:t1 + (x - t1)).map(lambda x:x.to_epoch_time()) */ suite.T().Log("About to run line #39: ts.Map(func(x r.Term) interface{} { return r.Add(t1, r.Sub(x, t1))}).Map(func(x r.Term) interface{} { return x.ToEpochTime()})") runAndAssert(suite.Suite, expected_, ts.Map(func(x r.Term) interface{} { return r.Add(t1, r.Sub(x, t1)) }).Map(func(x r.Term) interface{} { return x.ToEpochTime() }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #39") } { // times/time_arith.yaml line #43 /* err("ReqlQueryLogicError", "Expected type NUMBER but found PTYPE<TIME>.", []) */ var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found PTYPE<TIME>.") /* ts.map(lambda x:(t1 + x) - t1).map(lambda x:x.to_epoch_time()) */ suite.T().Log("About to run line #43: ts.Map(func(x r.Term) interface{} { return r.Add(t1, x).Sub(t1)}).Map(func(x r.Term) interface{} { return x.ToEpochTime()})") runAndAssert(suite.Suite, expected_, ts.Map(func(x r.Term) interface{} { return r.Add(t1, x).Sub(t1) }).Map(func(x r.Term) interface{} { return x.ToEpochTime() }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #43") } { // times/time_arith.yaml line #47 /* ([rt1, rt2, rt3, rt4]) */ var expected_ []interface{} = []interface{}{rt1, rt2, rt3, rt4} /* ts.map(lambda x:t1 - (t1 - x)).map(lambda x:x.to_epoch_time()) */ suite.T().Log("About to run line #47: ts.Map(func(x r.Term) interface{} { return r.Sub(t1, r.Sub(t1, x))}).Map(func(x r.Term) interface{} { return x.ToEpochTime()})") runAndAssert(suite.Suite, expected_, ts.Map(func(x r.Term) interface{} { return r.Sub(t1, r.Sub(t1, x)) }).Map(func(x r.Term) interface{} { return x.ToEpochTime() }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #47") } { // times/time_arith.yaml line #52 /* ([[[false, true, true, false, true, false], [true, true, false, true, false, false], [true, true, false, true, false, false], [true, true, false, true, false, false]], [[false, false, false, true, true, true], [false, true, true, false, true, false], [true, true, false, true, false, false], [true, true, false, true, false, false]], [[false, false, false, true, true, true], [false, false, false, true, true, true], [false, true, true, false, true, false], [true, true, false, true, false, false]], [[false, false, false, true, true, true], [false, false, false, true, true, true], [false, false, false, true, true, true], [false, true, true, false, true, false]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{false, true, true, false, true, false}, []interface{}{true, true, false, true, false, false}, []interface{}{true, true, false, true, false, false}, []interface{}{true, true, false, true, false, false}}, []interface{}{[]interface{}{false, false, false, true, true, true}, []interface{}{false, true, true, false, true, false}, []interface{}{true, true, false, true, false, false}, []interface{}{true, true, false, true, false, false}}, []interface{}{[]interface{}{false, false, false, true, true, true}, []interface{}{false, false, false, true, true, true}, []interface{}{false, true, true, false, true, false}, []interface{}{true, true, false, true, false, false}}, []interface{}{[]interface{}{false, false, false, true, true, true}, []interface{}{false, false, false, true, true, true}, []interface{}{false, false, false, true, true, true}, []interface{}{false, true, true, false, true, false}}} /* ts.map(lambda x:ts.map(lambda y:[x < y, x <= y, x == y, x != y, x >= y, x > y])) */ suite.T().Log("About to run line #52: ts.Map(func(x r.Term) interface{} { return ts.Map(func(y r.Term) interface{} { return []interface{}{r.Lt(x, y), r.Le(x, y), r.Eq(x, y), r.Ne(x, y), r.Ge(x, y), r.Gt(x, y)}})})") runAndAssert(suite.Suite, expected_, ts.Map(func(x r.Term) interface{} { return ts.Map(func(y r.Term) interface{} { return []interface{}{r.Lt(x, y), r.Le(x, y), r.Eq(x, y), r.Ne(x, y), r.Ge(x, y), r.Gt(x, y)} }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #52") } // times/time_arith.yaml line #73 // datum_types = r.expr([null, true, false, 1, "1", [1], {"1":1}, r.binary(b'')]) suite.T().Log("Possibly executing: var datum_types r.Term = r.Expr([]interface{}{nil, true, false, 1, '1', []interface{}{1}, map[interface{}]interface{}{'1': 1, }, r.Binary([]byte{})})") datum_types := r.Expr([]interface{}{nil, true, false, 1, "1", []interface{}{1}, map[interface{}]interface{}{"1": 1}, r.Binary([]byte{})}) _ = datum_types // Prevent any noused variable errors { // times/time_arith.yaml line #79 /* ([[[true, true, false, true, false, false], [false, false, false, true, true, true]], [[true, true, false, true, false, false], [false, false, false, true, true, true]], [[true, true, false, true, false, false], [false, false, false, true, true, true]], [[true, true, false, true, false, false], [false, false, false, true, true, true]], [[false, false, false, true, true, true], [true, true, false, true, false, false]], [[true, true, false, true, false, false], [false, false, false, true, true, true]], [[true, true, false, true, false, false], [false, false, false, true, true, true]], [[true, true, false, true, false, false], [false, false, false, true, true, true]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{false, false, false, true, true, true}, []interface{}{true, true, false, true, false, false}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}, []interface{}{[]interface{}{true, true, false, true, false, false}, []interface{}{false, false, false, true, true, true}}} /* datum_types.map(lambda x:r.expr([[x, t1], [t1, x]]).map(lambda xy:xy[0].do(lambda x2:xy[1].do(lambda y:[x2 < y, x2 <= y, x2 == y, x2 != y, x2 >= y, x2 > y])))) */ suite.T().Log("About to run line #79: datum_types.Map(func(x r.Term) interface{} { return r.Expr([]interface{}{[]interface{}{x, t1}, []interface{}{t1, x}}).Map(func(xy r.Term) interface{} { return xy.AtIndex(0).Do(func(x2 r.Term) interface{} { return xy.AtIndex(1).Do(func(y r.Term) interface{} { return []interface{}{r.Lt(x2, y), r.Le(x2, y), r.Eq(x2, y), r.Ne(x2, y), r.Ge(x2, y), r.Gt(x2, y)}})})})})") runAndAssert(suite.Suite, expected_, datum_types.Map(func(x r.Term) interface{} { return r.Expr([]interface{}{[]interface{}{x, t1}, []interface{}{t1, x}}).Map(func(xy r.Term) interface{} { return xy.AtIndex(0).Do(func(x2 r.Term) interface{} { return xy.AtIndex(1).Do(func(y r.Term) interface{} { return []interface{}{r.Lt(x2, y), r.Le(x2, y), r.Eq(x2, y), r.Ne(x2, y), r.Ge(x2, y), r.Gt(x2, y)} }) }) }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #79") } { // times/time_arith.yaml line #99 /* ([[[false, true, true, true], [false, false, true, true], [false, false, false, true], [false, false, false, false]], [[false, false, false, false], [false, false, true, true], [false, false, false, true], [false, false, false, false]], [[false, false, false, false], [false, false, false, false], [false, false, false, true], [false, false, false, false]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, false]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{false, true, true, true}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, true}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}}} /* ts.map(lambda a:ts.map(lambda b:ts.map(lambda c:b.during(a, c)))) */ suite.T().Log("About to run line #99: ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c)})})})") runAndAssert(suite.Suite, expected_, ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c) }) }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #99") } { // times/time_arith.yaml line #119 /* ([[[false, false, false, false], [false, false, true, true], [false, false, false, true], [false, false, false, false]], [[false, false, false, false], [false, false, false, false], [false, false, false, true], [false, false, false, false]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, false]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, false]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, true}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}}} /* ts.map(lambda a:ts.map(lambda b:ts.map(lambda c:b.during(a, c, left_bound='open')))) */ suite.T().Log("About to run line #119: ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{LeftBound: 'open', })})})})") runAndAssert(suite.Suite, expected_, ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{LeftBound: "open"}) }) }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #119") } { // times/time_arith.yaml line #139 /* ([[[true, true, true, true], [false, true, true, true], [false, false, true, true], [false, false, false, true]], [[false, false, false, false], [false, true, true, true], [false, false, true, true], [false, false, false, true]], [[false, false, false, false], [false, false, false, false], [false, false, true, true], [false, false, false, true]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, true]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{true, true, true, true}, []interface{}{false, true, true, true}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, true, true, true}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, true}}} /* ts.map(lambda a:ts.map(lambda b:ts.map(lambda c:b.during(a, c, right_bound='closed')))) */ suite.T().Log("About to run line #139: ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{RightBound: 'closed', })})})})") runAndAssert(suite.Suite, expected_, ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{RightBound: "closed"}) }) }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #139") } { // times/time_arith.yaml line #159 /* ([[[false, false, false, false], [false, true, true, true], [false, false, true, true], [false, false, false, true]], [[false, false, false, false], [false, false, false, false], [false, false, true, true], [false, false, false, true]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, true]], [[false, false, false, false], [false, false, false, false], [false, false, false, false], [false, false, false, false]]]) */ var expected_ []interface{} = []interface{}{[]interface{}{[]interface{}{false, false, false, false}, []interface{}{false, true, true, true}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, true, true}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, true}}, []interface{}{[]interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}, []interface{}{false, false, false, false}}} /* ts.map(lambda a:ts.map(lambda b:ts.map(lambda c:b.during(a, c, left_bound='open', right_bound='closed')))) */ suite.T().Log("About to run line #159: ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{LeftBound: 'open', RightBound: 'closed', })})})})") runAndAssert(suite.Suite, expected_, ts.Map(func(a r.Term) interface{} { return ts.Map(func(b r.Term) interface{} { return ts.Map(func(c r.Term) interface{} { return b.During(a, c).OptArgs(r.DuringOpts{LeftBound: "open", RightBound: "closed"}) }) }) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #159") } { // times/time_arith.yaml line #179 /* rts */ var expected_ []interface{} = rts /* ts.map(lambda x:x.date() + x.time_of_day()).map(lambda x:x.to_epoch_time()) */ suite.T().Log("About to run line #179: ts.Map(func(x r.Term) interface{} { return x.Date().Add(x.TimeOfDay())}).Map(func(x r.Term) interface{} { return x.ToEpochTime()})") runAndAssert(suite.Suite, expected_, ts.Map(func(x r.Term) interface{} { return x.Date().Add(x.TimeOfDay()) }).Map(func(x r.Term) interface{} { return x.ToEpochTime() }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #179") } { // times/time_arith.yaml line #185 /* rt1 */ var expected_ float64 = rt1 /* r.epoch_time(rt1).do(r.js("(function(data){return data})")).to_epoch_time() */ suite.T().Log("About to run line #185: r.EpochTime(rt1).Do(r.JS('(function(data){return data})')).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.EpochTime(rt1).Do(r.JS("(function(data){return data})")).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #185") } { // times/time_arith.yaml line #190 /* ("2012-08-01T00:00:00+00:00") */ var expected_ string = "2012-08-01T00:00:00+00:00" /* r.do(r.js("new Date('2012-08-01')")).to_iso8601() */ suite.T().Log("About to run line #190: r.Do(r.JS('new Date('2012-08-01')')).ToISO8601()") runAndAssert(suite.Suite, expected_, r.Do(r.JS("new Date('2012-08-01')")).ToISO8601(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #190") } { // times/time_arith.yaml line #195 /* ("2012-08-01T00:00:00+00:00") */ var expected_ string = "2012-08-01T00:00:00+00:00" /* r.do(r.js("(function(x){doc = new Object(); doc.date = new Date('2012-08-01'); return doc;})"))["date"].to_iso8601() */ suite.T().Log("About to run line #195: r.Do(r.JS('(function(x){doc = new Object(); doc.date = new Date('2012-08-01'); return doc;})')).AtIndex('date').ToISO8601()") runAndAssert(suite.Suite, expected_, r.Do(r.JS("(function(x){doc = new Object(); doc.date = new Date('2012-08-01'); return doc;})")).AtIndex("date").ToISO8601(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #195") } }
func (suite *TransformArraySuite) TestCases() { suite.T().Log("Running TransformArraySuite: Tests manipulation operations on arrays") // transform/array.yaml line #5 // arr = r.expr([1, 2, 3]) suite.T().Log("Possibly executing: var arr r.Term = r.Expr([]interface{}{1, 2, 3})") arr := r.Expr([]interface{}{1, 2, 3}) _ = arr // Prevent any noused variable errors // transform/array.yaml line #6 // dupe_arr = r.expr([1, 1, 2, 3]) suite.T().Log("Possibly executing: var dupe_arr r.Term = r.Expr([]interface{}{1, 1, 2, 3})") dupe_arr := r.Expr([]interface{}{1, 1, 2, 3}) _ = dupe_arr // Prevent any noused variable errors // transform/array.yaml line #7 // objArr = r.expr([{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}]) suite.T().Log("Possibly executing: var objArr r.Term = r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, 'b': 'a', }, map[interface{}]interface{}{'a': 2, 'b': 'b', }, map[interface{}]interface{}{'a': 3, 'b': 'c', }})") objArr := r.Expr([]interface{}{map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}}) _ = objArr // Prevent any noused variable errors // transform/array.yaml line #8 // nestedObjArr = r.expr([{'a':1, 'b':{'c':1}}, {'a':2, 'b':{'c':2}}, {'a':3, 'b':{'c':3}}]) suite.T().Log("Possibly executing: var nestedObjArr r.Term = r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, 'b': map[interface{}]interface{}{'c': 1, }, }, map[interface{}]interface{}{'a': 2, 'b': map[interface{}]interface{}{'c': 2, }, }, map[interface{}]interface{}{'a': 3, 'b': map[interface{}]interface{}{'c': 3, }, }})") nestedObjArr := r.Expr([]interface{}{map[interface{}]interface{}{"a": 1, "b": map[interface{}]interface{}{"c": 1}}, map[interface{}]interface{}{"a": 2, "b": map[interface{}]interface{}{"c": 2}}, map[interface{}]interface{}{"a": 3, "b": map[interface{}]interface{}{"c": 3}}}) _ = nestedObjArr // Prevent any noused variable errors { // transform/array.yaml line #12 /* [1,2,3,4] */ var expected_ []interface{} = []interface{}{1, 2, 3, 4} /* arr.append(4) */ suite.T().Log("About to run line #12: arr.Append(4)") runAndAssert(suite.Suite, expected_, arr.Append(4), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #12") } { // transform/array.yaml line #14 /* [1,2,3,'a'] */ var expected_ []interface{} = []interface{}{1, 2, 3, "a"} /* arr.append('a') */ suite.T().Log("About to run line #14: arr.Append('a')") runAndAssert(suite.Suite, expected_, arr.Append("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #14") } { // transform/array.yaml line #19 /* [0,1,2,3] */ var expected_ []interface{} = []interface{}{0, 1, 2, 3} /* arr.prepend(0) */ suite.T().Log("About to run line #19: arr.Prepend(0)") runAndAssert(suite.Suite, expected_, arr.Prepend(0), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #19") } { // transform/array.yaml line #21 /* ['a',1,2,3] */ var expected_ []interface{} = []interface{}{"a", 1, 2, 3} /* arr.prepend('a') */ suite.T().Log("About to run line #21: arr.Prepend('a')") runAndAssert(suite.Suite, expected_, arr.Prepend("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #21") } { // transform/array.yaml line #26 /* [3] */ var expected_ []interface{} = []interface{}{3} /* arr.difference([1,2,2]) */ suite.T().Log("About to run line #26: arr.Difference([]interface{}{1, 2, 2})") runAndAssert(suite.Suite, expected_, arr.Difference([]interface{}{1, 2, 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #26") } { // transform/array.yaml line #28 /* [1,2,3] */ var expected_ []interface{} = []interface{}{1, 2, 3} /* arr.difference([]) */ suite.T().Log("About to run line #28: arr.Difference([]interface{}{})") runAndAssert(suite.Suite, expected_, arr.Difference([]interface{}{}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #28") } { // transform/array.yaml line #30 /* [1,2,3] */ var expected_ []interface{} = []interface{}{1, 2, 3} /* arr.difference(["foo", "bar"]) */ suite.T().Log("About to run line #30: arr.Difference([]interface{}{'foo', 'bar'})") runAndAssert(suite.Suite, expected_, arr.Difference([]interface{}{"foo", "bar"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #30") } { // transform/array.yaml line #34 /* [1,2,3] */ var expected_ []interface{} = []interface{}{1, 2, 3} /* dupe_arr.set_insert(1) */ suite.T().Log("About to run line #34: dupe_arr.SetInsert(1)") runAndAssert(suite.Suite, expected_, dupe_arr.SetInsert(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #34") } { // transform/array.yaml line #36 /* [1,2,3,4] */ var expected_ []interface{} = []interface{}{1, 2, 3, 4} /* dupe_arr.set_insert(4) */ suite.T().Log("About to run line #36: dupe_arr.SetInsert(4)") runAndAssert(suite.Suite, expected_, dupe_arr.SetInsert(4), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #36") } { // transform/array.yaml line #39 /* [1,2,3,4,5] */ var expected_ []interface{} = []interface{}{1, 2, 3, 4, 5} /* dupe_arr.set_union([3,4,5,5]) */ suite.T().Log("About to run line #39: dupe_arr.SetUnion([]interface{}{3, 4, 5, 5})") runAndAssert(suite.Suite, expected_, dupe_arr.SetUnion([]interface{}{3, 4, 5, 5}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #39") } { // transform/array.yaml line #41 /* [1,2,3,5,6] */ var expected_ []interface{} = []interface{}{1, 2, 3, 5, 6} /* dupe_arr.set_union([5,6]) */ suite.T().Log("About to run line #41: dupe_arr.SetUnion([]interface{}{5, 6})") runAndAssert(suite.Suite, expected_, dupe_arr.SetUnion([]interface{}{5, 6}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #41") } { // transform/array.yaml line #44 /* [1,2] */ var expected_ []interface{} = []interface{}{1, 2} /* dupe_arr.set_intersection([1,1,1,2,2]) */ suite.T().Log("About to run line #44: dupe_arr.SetIntersection([]interface{}{1, 1, 1, 2, 2})") runAndAssert(suite.Suite, expected_, dupe_arr.SetIntersection([]interface{}{1, 1, 1, 2, 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #44") } { // transform/array.yaml line #46 /* [] */ var expected_ []interface{} = []interface{}{} /* dupe_arr.set_intersection(["foo"]) */ suite.T().Log("About to run line #46: dupe_arr.SetIntersection([]interface{}{'foo'})") runAndAssert(suite.Suite, expected_, dupe_arr.SetIntersection([]interface{}{"foo"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #46") } { // transform/array.yaml line #49 /* [2,3] */ var expected_ []interface{} = []interface{}{2, 3} /* dupe_arr.set_difference([1,1,1,10]) */ suite.T().Log("About to run line #49: dupe_arr.SetDifference([]interface{}{1, 1, 1, 10})") runAndAssert(suite.Suite, expected_, dupe_arr.SetDifference([]interface{}{1, 1, 1, 10}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #49") } { // transform/array.yaml line #51 /* [1,3] */ var expected_ []interface{} = []interface{}{1, 3} /* dupe_arr.set_difference([2]) */ suite.T().Log("About to run line #51: dupe_arr.SetDifference([]interface{}{2})") runAndAssert(suite.Suite, expected_, dupe_arr.SetDifference([]interface{}{2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #51") } { // transform/array.yaml line #58 /* [2, 3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr[1:3] */ suite.T().Log("About to run line #58: arr.Slice(1, 3)") runAndAssert(suite.Suite, expected_, arr.Slice(1, 3), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #58") } { // transform/array.yaml line #59 /* [2, 3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr.slice(1, 3) */ suite.T().Log("About to run line #59: arr.Slice(1, 3)") runAndAssert(suite.Suite, expected_, arr.Slice(1, 3), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #59") } { // transform/array.yaml line #60 /* [2, 3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr.slice(1, 2, right_bound='closed') */ suite.T().Log("About to run line #60: arr.Slice(1, 2).OptArgs(r.SliceOpts{RightBound: 'closed', })") runAndAssert(suite.Suite, expected_, arr.Slice(1, 2).OptArgs(r.SliceOpts{RightBound: "closed"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #60") } { // transform/array.yaml line #72 /* [1,2] */ var expected_ []interface{} = []interface{}{1, 2} /* arr[:2] */ suite.T().Log("About to run line #72: arr.Slice(0, 2)") runAndAssert(suite.Suite, expected_, arr.Slice(0, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #72") } { // transform/array.yaml line #73 /* [1,2] */ var expected_ []interface{} = []interface{}{1, 2} /* arr.slice(0,2) */ suite.T().Log("About to run line #73: arr.Slice(0, 2)") runAndAssert(suite.Suite, expected_, arr.Slice(0, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #73") } { // transform/array.yaml line #81 /* [2,3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr[1:] */ suite.T().Log("About to run line #81: arr.Slice(1, -1, r.SliceOpts{RightBound: 'closed'})") runAndAssert(suite.Suite, expected_, arr.Slice(1, -1, r.SliceOpts{RightBound: "closed"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #81") } { // transform/array.yaml line #82 /* [2,3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr.slice(1) */ suite.T().Log("About to run line #82: arr.Slice(1)") runAndAssert(suite.Suite, expected_, arr.Slice(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #82") } { // transform/array.yaml line #89 /* [2] */ var expected_ []interface{} = []interface{}{2} /* arr.slice(-2, -1) */ suite.T().Log("About to run line #89: arr.Slice(-2, -1)") runAndAssert(suite.Suite, expected_, arr.Slice(-2, -1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #89") } { // transform/array.yaml line #95 /* [2,3] */ var expected_ []interface{} = []interface{}{2, 3} /* arr.skip(1) */ suite.T().Log("About to run line #95: arr.Skip(1)") runAndAssert(suite.Suite, expected_, arr.Skip(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #95") } { // transform/array.yaml line #97 /* [3] */ var expected_ []interface{} = []interface{}{3} /* arr.skip(2) */ suite.T().Log("About to run line #97: arr.Skip(2)") runAndAssert(suite.Suite, expected_, arr.Skip(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #97") } { // transform/array.yaml line #99 /* [] */ var expected_ []interface{} = []interface{}{} /* arr.skip(12) */ suite.T().Log("About to run line #99: arr.Skip(12)") runAndAssert(suite.Suite, expected_, arr.Skip(12), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #99") } { // transform/array.yaml line #104 /* [1,2] */ var expected_ []interface{} = []interface{}{1, 2} /* arr.limit(2) */ suite.T().Log("About to run line #104: arr.Limit(2)") runAndAssert(suite.Suite, expected_, arr.Limit(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #104") } { // transform/array.yaml line #106 /* [] */ var expected_ []interface{} = []interface{}{} /* arr.limit(0) */ suite.T().Log("About to run line #106: arr.Limit(0)") runAndAssert(suite.Suite, expected_, arr.Limit(0), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #106") } { // transform/array.yaml line #108 /* [1,2,3] */ var expected_ []interface{} = []interface{}{1, 2, 3} /* arr.limit(12) */ suite.T().Log("About to run line #108: arr.Limit(12)") runAndAssert(suite.Suite, expected_, arr.Limit(12), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #108") } { // transform/array.yaml line #113 /* [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}} /* objArr.pluck('a', 'b') */ suite.T().Log("About to run line #113: objArr.Pluck('a', 'b')") runAndAssert(suite.Suite, expected_, objArr.Pluck("a", "b"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #113") } { // transform/array.yaml line #115 /* [{'a':1}, {'a':2}, {'a':3}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": 2}, map[interface{}]interface{}{"a": 3}} /* objArr.pluck('a') */ suite.T().Log("About to run line #115: objArr.Pluck('a')") runAndAssert(suite.Suite, expected_, objArr.Pluck("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #115") } { // transform/array.yaml line #117 /* [{}, {}, {}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}} /* objArr.pluck() */ suite.T().Log("About to run line #117: objArr.Pluck()") runAndAssert(suite.Suite, expected_, objArr.Pluck(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #117") } // transform/array.yaml line #121 // wftst = objArr.union(objArr.pluck('a')).union(objArr.pluck('b')).union([{'a':null}]) suite.T().Log("Possibly executing: var wftst r.Term = objArr.Union(objArr.Pluck('a')).Union(objArr.Pluck('b')).Union([]interface{}{map[interface{}]interface{}{'a': nil, }})") wftst := objArr.Union(objArr.Pluck("a")).Union(objArr.Pluck("b")).Union([]interface{}{map[interface{}]interface{}{"a": nil}}) _ = wftst // Prevent any noused variable errors { // transform/array.yaml line #122 /* ([{'a':1},{'a':2},{'a':3},{'a':1},{'a':2},{'a':3}]) */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": 2}, map[interface{}]interface{}{"a": 3}, map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": 2}, map[interface{}]interface{}{"a": 3}} /* wftst.with_fields('a') */ suite.T().Log("About to run line #122: wftst.WithFields('a')") runAndAssert(suite.Suite, expected_, wftst.WithFields("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #122") } { // transform/array.yaml line #124 /* ([{'b':'a'},{'b':'b'},{'b':'c'},{'b':'a'},{'b':'b'},{'b':'c'}]) */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"b": "a"}, map[interface{}]interface{}{"b": "b"}, map[interface{}]interface{}{"b": "c"}, map[interface{}]interface{}{"b": "a"}, map[interface{}]interface{}{"b": "b"}, map[interface{}]interface{}{"b": "c"}} /* wftst.with_fields('b') */ suite.T().Log("About to run line #124: wftst.WithFields('b')") runAndAssert(suite.Suite, expected_, wftst.WithFields("b"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #124") } { // transform/array.yaml line #126 /* ([{'a':1,'b':'a'},{'a':2,'b':'b'},{'a':3,'b':'c'}]) */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}} /* wftst.with_fields('a', 'b') */ suite.T().Log("About to run line #126: wftst.WithFields('a', 'b')") runAndAssert(suite.Suite, expected_, wftst.WithFields("a", "b"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #126") } { // transform/array.yaml line #128 /* [{}, {}, {}, {}, {}, {}, {}, {}, {}, {}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}} /* wftst.with_fields() */ suite.T().Log("About to run line #128: wftst.WithFields()") runAndAssert(suite.Suite, expected_, wftst.WithFields(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #128") } // transform/array.yaml line #131 // wftst2 = nestedObjArr.union(objArr.pluck({'b':'missing'})).union(nestedObjArr.pluck({'b':'c'})) suite.T().Log("Possibly executing: var wftst2 r.Term = nestedObjArr.Union(objArr.Pluck(map[interface{}]interface{}{'b': 'missing', })).Union(nestedObjArr.Pluck(map[interface{}]interface{}{'b': 'c', }))") wftst2 := nestedObjArr.Union(objArr.Pluck(map[interface{}]interface{}{"b": "missing"})).Union(nestedObjArr.Pluck(map[interface{}]interface{}{"b": "c"})) _ = wftst2 // Prevent any noused variable errors { // transform/array.yaml line #132 /* ([{'b':{'c':1}}, {'b':{'c':2}}, {'b':{'c':3}}, {'b':{'c':1}}, {'b':{'c':2}}, {'b':{'c':3}}]) */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 1}}, map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 2}}, map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 3}}, map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 1}}, map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 2}}, map[interface{}]interface{}{"b": map[interface{}]interface{}{"c": 3}}} /* wftst2.with_fields({'b':'c'}) */ suite.T().Log("About to run line #132: wftst2.WithFields(map[interface{}]interface{}{'b': 'c', })") runAndAssert(suite.Suite, expected_, wftst2.WithFields(map[interface{}]interface{}{"b": "c"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #132") } { // transform/array.yaml line #135 /* err("ReqlQueryLogicError", "Invalid path argument `1`.", []) */ var expected_ Err = err("ReqlQueryLogicError", "Invalid path argument `1`.") /* wftst.with_fields(1) */ suite.T().Log("About to run line #135: wftst.WithFields(1)") runAndAssert(suite.Suite, expected_, wftst.WithFields(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #135") } { // transform/array.yaml line #137 /* err("ReqlQueryLogicError", "Cannot perform has_fields on a non-object non-sequence `1`.", []) */ var expected_ Err = err("ReqlQueryLogicError", "Cannot perform has_fields on a non-object non-sequence `1`.") /* r.expr(1).with_fields() */ suite.T().Log("About to run line #137: r.Expr(1).WithFields()") runAndAssert(suite.Suite, expected_, r.Expr(1).WithFields(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #137") } { // transform/array.yaml line #142 /* [{}, {}, {}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{}, map[interface{}]interface{}{}} /* objArr.without('a', 'b') */ suite.T().Log("About to run line #142: objArr.Without('a', 'b')") runAndAssert(suite.Suite, expected_, objArr.Without("a", "b"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #142") } { // transform/array.yaml line #144 /* [{'b':'a'}, {'b':'b'}, {'b':'c'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"b": "a"}, map[interface{}]interface{}{"b": "b"}, map[interface{}]interface{}{"b": "c"}} /* objArr.without('a') */ suite.T().Log("About to run line #144: objArr.Without('a')") runAndAssert(suite.Suite, expected_, objArr.Without("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #144") } { // transform/array.yaml line #146 /* [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}} /* objArr.without() */ suite.T().Log("About to run line #146: objArr.Without()") runAndAssert(suite.Suite, expected_, objArr.Without(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #146") } { // transform/array.yaml line #151 /* [2,3,4] */ var expected_ []interface{} = []interface{}{2, 3, 4} /* arr.map(lambda v: v + 1) */ suite.T().Log("About to run line #151: arr.Map(func(v r.Term) interface{} { return r.Add(v, 1)})") runAndAssert(suite.Suite, expected_, arr.Map(func(v r.Term) interface{} { return r.Add(v, 1) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #151") } { // transform/array.yaml line #161 /* 6 */ var expected_ int = 6 /* arr.reduce(lambda a, b: a + b) */ suite.T().Log("About to run line #161: arr.Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)})") runAndAssert(suite.Suite, expected_, arr.Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #161") } { // transform/array.yaml line #166 /* 6 */ var expected_ int = 6 /* arr.reduce(lambda a, b:a + b) */ suite.T().Log("About to run line #166: arr.Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)})") runAndAssert(suite.Suite, expected_, arr.Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #166") } { // transform/array.yaml line #171 /* 12 */ var expected_ int = 12 /* arr.union(arr).reduce(lambda a, b: a + b) */ suite.T().Log("About to run line #171: arr.Union(arr).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)})") runAndAssert(suite.Suite, expected_, arr.Union(arr).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #171") } { // transform/array.yaml line #176 /* 12 */ var expected_ int = 12 /* arr.union(arr).reduce(lambda a, b:a + b) */ suite.T().Log("About to run line #176: arr.Union(arr).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)})") runAndAssert(suite.Suite, expected_, arr.Union(arr).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #176") } { // transform/array.yaml line #183 /* [{'a':2, 'b':'b'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 2, "b": "b"}} /* objArr.filter(lambda row: row['b'] == 'b') */ suite.T().Log("About to run line #183: objArr.Filter(func(row r.Term) interface{} { return row.AtIndex('b').Eq('b')})") runAndAssert(suite.Suite, expected_, objArr.Filter(func(row r.Term) interface{} { return row.AtIndex("b").Eq("b") }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #183") } { // transform/array.yaml line #190 /* [1,2,1,2,1,2] */ var expected_ []interface{} = []interface{}{1, 2, 1, 2, 1, 2} /* arr.concat_map(lambda v: [1,2]) */ suite.T().Log("About to run line #190: arr.ConcatMap(func(v r.Term) interface{} { return []interface{}{1, 2}})") runAndAssert(suite.Suite, expected_, arr.ConcatMap(func(v r.Term) interface{} { return []interface{}{1, 2} }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #190") } { // transform/array.yaml line #194 /* [{'v':1}, {'v2':2}, {'v':2}, {'v2':3}, {'v':3}, {'v2':4}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"v": 1}, map[interface{}]interface{}{"v2": 2}, map[interface{}]interface{}{"v": 2}, map[interface{}]interface{}{"v2": 3}, map[interface{}]interface{}{"v": 3}, map[interface{}]interface{}{"v2": 4}} /* arr.concat_map(lambda v: [{'v':v}, {'v2':v + 1}]) */ suite.T().Log("About to run line #194: arr.ConcatMap(func(v r.Term) interface{} { return []interface{}{map[interface{}]interface{}{'v': v, }, map[interface{}]interface{}{'v2': r.Add(v, 1), }}})") runAndAssert(suite.Suite, expected_, arr.ConcatMap(func(v r.Term) interface{} { return []interface{}{map[interface{}]interface{}{"v": v}, map[interface{}]interface{}{"v2": r.Add(v, 1)}} }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #194") } { // transform/array.yaml line #201 /* [{'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}} /* objArr.order_by('b') */ suite.T().Log("About to run line #201: objArr.OrderBy('b')") runAndAssert(suite.Suite, expected_, objArr.OrderBy("b"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #201") } { // transform/array.yaml line #205 /* [{'a':3, 'b':'c'}, {'a':2, 'b':'b'}, {'a':1, 'b':'a'}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 3, "b": "c"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 1, "b": "a"}} /* objArr.order_by(r.desc('b')) */ suite.T().Log("About to run line #205: objArr.OrderBy(r.Desc('b'))") runAndAssert(suite.Suite, expected_, objArr.OrderBy(r.Desc("b")), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #205") } { // transform/array.yaml line #208 /* [{'-a':1},{'-a':2}] */ var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"-a": 1}, map[interface{}]interface{}{"-a": 2}} /* r.expr([{'-a':1},{'-a':2}]).order_by('-a') */ suite.T().Log("About to run line #208: r.Expr([]interface{}{map[interface{}]interface{}{'-a': 1, }, map[interface{}]interface{}{'-a': 2, }}).OrderBy('-a')") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{map[interface{}]interface{}{"-a": 1}, map[interface{}]interface{}{"-a": 2}}).OrderBy("-a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #208") } { // transform/array.yaml line #216 /* [1,2,3,4] */ var expected_ []interface{} = []interface{}{1, 2, 3, 4} /* r.expr([1,1,2,2,2,3,4]).distinct() */ suite.T().Log("About to run line #216: r.Expr([]interface{}{1, 1, 2, 2, 2, 3, 4}).Distinct()") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 1, 2, 2, 2, 3, 4}).Distinct(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #216") } { // transform/array.yaml line #223 /* 3 */ var expected_ int = 3 /* objArr.count() */ suite.T().Log("About to run line #223: objArr.Count()") runAndAssert(suite.Suite, expected_, objArr.Count(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #223") } { // transform/array.yaml line #228 /* [1, 2, 3, {'a':1, 'b':'a'}, {'a':2, 'b':'b'}, {'a':3, 'b':'c'}] */ var expected_ []interface{} = []interface{}{1, 2, 3, map[interface{}]interface{}{"a": 1, "b": "a"}, map[interface{}]interface{}{"a": 2, "b": "b"}, map[interface{}]interface{}{"a": 3, "b": "c"}} /* arr.union(objArr) */ suite.T().Log("About to run line #228: arr.Union(objArr)") runAndAssert(suite.Suite, expected_, arr.Union(objArr), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #228") } { // transform/array.yaml line #234 /* 2 */ var expected_ int = 2 /* arr[1] */ suite.T().Log("About to run line #234: arr.AtIndex(1)") runAndAssert(suite.Suite, expected_, arr.AtIndex(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #234") } { // transform/array.yaml line #235 /* 2 */ var expected_ int = 2 /* arr.nth(1) */ suite.T().Log("About to run line #235: arr.Nth(1)") runAndAssert(suite.Suite, expected_, arr.Nth(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #235") } { // transform/array.yaml line #238 /* 1 */ var expected_ int = 1 /* arr[0] */ suite.T().Log("About to run line #238: arr.AtIndex(0)") runAndAssert(suite.Suite, expected_, arr.AtIndex(0), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #238") } { // transform/array.yaml line #245 /* true */ var expected_ bool = true /* r.expr([]).is_empty() */ suite.T().Log("About to run line #245: r.Expr([]interface{}{}).IsEmpty()") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).IsEmpty(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #245") } { // transform/array.yaml line #247 /* false */ var expected_ bool = false /* arr.is_empty() */ suite.T().Log("About to run line #247: arr.IsEmpty()") runAndAssert(suite.Suite, expected_, arr.IsEmpty(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #247") } { // transform/array.yaml line #251 /* true */ var expected_ bool = true /* arr.contains(2) */ suite.T().Log("About to run line #251: arr.Contains(2)") runAndAssert(suite.Suite, expected_, arr.Contains(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #251") } { // transform/array.yaml line #253 /* true */ var expected_ bool = true /* arr.contains(2, 3) */ suite.T().Log("About to run line #253: arr.Contains(2, 3)") runAndAssert(suite.Suite, expected_, arr.Contains(2, 3), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #253") } { // transform/array.yaml line #255 /* false */ var expected_ bool = false /* arr.contains(4) */ suite.T().Log("About to run line #255: arr.Contains(4)") runAndAssert(suite.Suite, expected_, arr.Contains(4), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #255") } { // transform/array.yaml line #257 /* false */ var expected_ bool = false /* arr.contains(2, 4) */ suite.T().Log("About to run line #257: arr.Contains(2, 4)") runAndAssert(suite.Suite, expected_, arr.Contains(2, 4), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #257") } { // transform/array.yaml line #259 /* false */ var expected_ bool = false /* arr.contains(2, 2) */ suite.T().Log("About to run line #259: arr.Contains(2, 2)") runAndAssert(suite.Suite, expected_, arr.Contains(2, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #259") } { // transform/array.yaml line #261 /* true */ var expected_ bool = true /* arr.union(arr).contains(2, 2) */ suite.T().Log("About to run line #261: arr.Union(arr).Contains(2, 2)") runAndAssert(suite.Suite, expected_, arr.Union(arr).Contains(2, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #261") } { // transform/array.yaml line #265 /* true */ var expected_ bool = true /* arr.contains(lambda x:x == 2) */ suite.T().Log("About to run line #265: arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2)})") runAndAssert(suite.Suite, expected_, arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #265") } { // transform/array.yaml line #269 /* true */ var expected_ bool = true /* arr.contains(lambda x:x == 2, lambda x:x==3) */ suite.T().Log("About to run line #269: arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2)}, func(x r.Term) interface{} { return r.Eq(x, 3)})") runAndAssert(suite.Suite, expected_, arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2) }, func(x r.Term) interface{} { return r.Eq(x, 3) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #269") } { // transform/array.yaml line #273 /* false */ var expected_ bool = false /* arr.contains(lambda x:x == 4) */ suite.T().Log("About to run line #273: arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 4)})") runAndAssert(suite.Suite, expected_, arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 4) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #273") } { // transform/array.yaml line #277 /* false */ var expected_ bool = false /* arr.contains(lambda x:x == 2, lambda x:x==4) */ suite.T().Log("About to run line #277: arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2)}, func(x r.Term) interface{} { return r.Eq(x, 4)})") runAndAssert(suite.Suite, expected_, arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2) }, func(x r.Term) interface{} { return r.Eq(x, 4) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #277") } { // transform/array.yaml line #281 /* false */ var expected_ bool = false /* arr.contains(lambda x:x == 2, lambda x:x==2) */ suite.T().Log("About to run line #281: arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2)}, func(x r.Term) interface{} { return r.Eq(x, 2)})") runAndAssert(suite.Suite, expected_, arr.Contains(func(x r.Term) interface{} { return r.Eq(x, 2) }, func(x r.Term) interface{} { return r.Eq(x, 2) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #281") } { // transform/array.yaml line #285 /* true */ var expected_ bool = true /* arr.union(arr).contains(lambda x:x == 2, lambda x:x==2) */ suite.T().Log("About to run line #285: arr.Union(arr).Contains(func(x r.Term) interface{} { return r.Eq(x, 2)}, func(x r.Term) interface{} { return r.Eq(x, 2)})") runAndAssert(suite.Suite, expected_, arr.Union(arr).Contains(func(x r.Term) interface{} { return r.Eq(x, 2) }, func(x r.Term) interface{} { return r.Eq(x, 2) }), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #285") } { // transform/array.yaml line #290 /* [1, 3] */ var expected_ []interface{} = []interface{}{1, 3} /* r.expr([{'a':1},{'b':2},{'a':3,'c':4}])['a'] */ suite.T().Log("About to run line #290: r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, }, map[interface{}]interface{}{'b': 2, }, map[interface{}]interface{}{'a': 3, 'c': 4, }}).AtIndex('a')") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"b": 2}, map[interface{}]interface{}{"a": 3, "c": 4}}).AtIndex("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #290") } { // transform/array.yaml line #293 /* err("ReqlQueryLogicError", "Cannot perform bracket on a non-object non-sequence `\"a\"`.", []) */ var expected_ Err = err("ReqlQueryLogicError", "Cannot perform bracket on a non-object non-sequence `\"a\"`.") /* r.expr([{'a':1},'a',{'b':2},{'a':3,'c':4}])['a'] */ suite.T().Log("About to run line #293: r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, }, 'a', map[interface{}]interface{}{'b': 2, }, map[interface{}]interface{}{'a': 3, 'c': 4, }}).AtIndex('a')") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{map[interface{}]interface{}{"a": 1}, "a", map[interface{}]interface{}{"b": 2}, map[interface{}]interface{}{"a": 3, "c": 4}}).AtIndex("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #293") } }
func (suite *MathLogicAliasesSuite) TestCases() { suite.T().Log("Running MathLogicAliasesSuite: Test named aliases for math and logic operators") { // math_logic/aliases.yaml line #5 /* 1 */ var expected_ int = 1 /* r.expr(0).add(1) */ suite.T().Log("About to run line #5: r.Expr(0).Add(1)") runAndAssert(suite.Suite, expected_, r.Expr(0).Add(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #5") } { // math_logic/aliases.yaml line #6 /* 1 */ var expected_ int = 1 /* r.add(0, 1) */ suite.T().Log("About to run line #6: r.Add(0, 1)") runAndAssert(suite.Suite, expected_, r.Add(0, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #6") } { // math_logic/aliases.yaml line #7 /* 1 */ var expected_ int = 1 /* r.expr(2).sub(1) */ suite.T().Log("About to run line #7: r.Expr(2).Sub(1)") runAndAssert(suite.Suite, expected_, r.Expr(2).Sub(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #7") } { // math_logic/aliases.yaml line #8 /* 1 */ var expected_ int = 1 /* r.sub(2, 1) */ suite.T().Log("About to run line #8: r.Sub(2, 1)") runAndAssert(suite.Suite, expected_, r.Sub(2, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #8") } { // math_logic/aliases.yaml line #9 /* 1 */ var expected_ int = 1 /* r.expr(2).div(2) */ suite.T().Log("About to run line #9: r.Expr(2).Div(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Div(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #9") } { // math_logic/aliases.yaml line #10 /* 1 */ var expected_ int = 1 /* r.div(2, 2) */ suite.T().Log("About to run line #10: r.Div(2, 2)") runAndAssert(suite.Suite, expected_, r.Div(2, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #10") } { // math_logic/aliases.yaml line #11 /* 1 */ var expected_ int = 1 /* r.expr(1).mul(1) */ suite.T().Log("About to run line #11: r.Expr(1).Mul(1)") runAndAssert(suite.Suite, expected_, r.Expr(1).Mul(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #11") } { // math_logic/aliases.yaml line #12 /* 1 */ var expected_ int = 1 /* r.mul(1, 1) */ suite.T().Log("About to run line #12: r.Mul(1, 1)") runAndAssert(suite.Suite, expected_, r.Mul(1, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #12") } { // math_logic/aliases.yaml line #13 /* 1 */ var expected_ int = 1 /* r.expr(1).mod(2) */ suite.T().Log("About to run line #13: r.Expr(1).Mod(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Mod(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #13") } { // math_logic/aliases.yaml line #14 /* 1 */ var expected_ int = 1 /* r.mod(1, 2) */ suite.T().Log("About to run line #14: r.Mod(1, 2)") runAndAssert(suite.Suite, expected_, r.Mod(1, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #14") } { // math_logic/aliases.yaml line #25 /* True */ var expected_ bool = true /* r.expr(True).and_(True) */ suite.T().Log("About to run line #25: r.Expr(true).And(true)") runAndAssert(suite.Suite, expected_, r.Expr(true).And(true), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #25") } { // math_logic/aliases.yaml line #26 /* True */ var expected_ bool = true /* r.expr(True).or_(True) */ suite.T().Log("About to run line #26: r.Expr(true).Or(true)") runAndAssert(suite.Suite, expected_, r.Expr(true).Or(true), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #26") } { // math_logic/aliases.yaml line #27 /* True */ var expected_ bool = true /* r.and_(True, True) */ suite.T().Log("About to run line #27: r.And(true, true)") runAndAssert(suite.Suite, expected_, r.And(true, true), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #27") } { // math_logic/aliases.yaml line #28 /* True */ var expected_ bool = true /* r.or_(True, True) */ suite.T().Log("About to run line #28: r.Or(true, true)") runAndAssert(suite.Suite, expected_, r.Or(true, true), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #28") } { // math_logic/aliases.yaml line #29 /* True */ var expected_ bool = true /* r.expr(False).not_() */ suite.T().Log("About to run line #29: r.Expr(false).Not()") runAndAssert(suite.Suite, expected_, r.Expr(false).Not(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #29") } { // math_logic/aliases.yaml line #30 /* True */ var expected_ bool = true /* r.not_(False) */ suite.T().Log("About to run line #30: r.Not(false)") runAndAssert(suite.Suite, expected_, r.Not(false), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #30") } { // math_logic/aliases.yaml line #34 /* True */ var expected_ bool = true /* r.expr(1).eq(1) */ suite.T().Log("About to run line #34: r.Expr(1).Eq(1)") runAndAssert(suite.Suite, expected_, r.Expr(1).Eq(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #34") } { // math_logic/aliases.yaml line #35 /* True */ var expected_ bool = true /* r.expr(1).ne(2) */ suite.T().Log("About to run line #35: r.Expr(1).Ne(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ne(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #35") } { // math_logic/aliases.yaml line #36 /* True */ var expected_ bool = true /* r.expr(1).lt(2) */ suite.T().Log("About to run line #36: r.Expr(1).Lt(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Lt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #36") } { // math_logic/aliases.yaml line #37 /* True */ var expected_ bool = true /* r.expr(1).gt(0) */ suite.T().Log("About to run line #37: r.Expr(1).Gt(0)") runAndAssert(suite.Suite, expected_, r.Expr(1).Gt(0), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #37") } { // math_logic/aliases.yaml line #38 /* True */ var expected_ bool = true /* r.expr(1).le(1) */ suite.T().Log("About to run line #38: r.Expr(1).Le(1)") runAndAssert(suite.Suite, expected_, r.Expr(1).Le(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #38") } { // math_logic/aliases.yaml line #39 /* True */ var expected_ bool = true /* r.expr(1).ge(1) */ suite.T().Log("About to run line #39: r.Expr(1).Ge(1)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ge(1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #39") } { // math_logic/aliases.yaml line #40 /* True */ var expected_ bool = true /* r.eq(1, 1) */ suite.T().Log("About to run line #40: r.Eq(1, 1)") runAndAssert(suite.Suite, expected_, r.Eq(1, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #40") } { // math_logic/aliases.yaml line #41 /* True */ var expected_ bool = true /* r.ne(1, 2) */ suite.T().Log("About to run line #41: r.Ne(1, 2)") runAndAssert(suite.Suite, expected_, r.Ne(1, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #41") } { // math_logic/aliases.yaml line #42 /* True */ var expected_ bool = true /* r.lt(1, 2) */ suite.T().Log("About to run line #42: r.Lt(1, 2)") runAndAssert(suite.Suite, expected_, r.Lt(1, 2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #42") } { // math_logic/aliases.yaml line #43 /* True */ var expected_ bool = true /* r.gt(1, 0) */ suite.T().Log("About to run line #43: r.Gt(1, 0)") runAndAssert(suite.Suite, expected_, r.Gt(1, 0), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #43") } { // math_logic/aliases.yaml line #44 /* True */ var expected_ bool = true /* r.le(1, 1) */ suite.T().Log("About to run line #44: r.Le(1, 1)") runAndAssert(suite.Suite, expected_, r.Le(1, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #44") } { // math_logic/aliases.yaml line #45 /* True */ var expected_ bool = true /* r.ge(1, 1) */ suite.T().Log("About to run line #45: r.Ge(1, 1)") runAndAssert(suite.Suite, expected_, r.Ge(1, 1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #45") } }
func (suite *MathLogicComparisonSuite) TestCases() { suite.T().Log("Running MathLogicComparisonSuite: Tests of comparison operators") { // math_logic/comparison.yaml line #10 /* true */ var expected_ bool = true /* r.expr(1) < 2 */ suite.T().Log("About to run line #10: r.Expr(1).Lt(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Lt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #10") } { // math_logic/comparison.yaml line #11 /* true */ var expected_ bool = true /* 1 < r.expr(2) */ suite.T().Log("About to run line #11: r.Lt(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Lt(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #11") } { // math_logic/comparison.yaml line #12 /* true */ var expected_ bool = true /* r.expr(1).lt(2) */ suite.T().Log("About to run line #12: r.Expr(1).Lt(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Lt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #12") } { // math_logic/comparison.yaml line #19 /* false */ var expected_ bool = false /* r.expr(3) < 2 */ suite.T().Log("About to run line #19: r.Expr(3).Lt(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Lt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #19") } { // math_logic/comparison.yaml line #22 /* false */ var expected_ bool = false /* r.expr(2) < 2 */ suite.T().Log("About to run line #22: r.Expr(2).Lt(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Lt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #22") } { // math_logic/comparison.yaml line #38 /* false */ var expected_ bool = false /* r.expr(1) > 2 */ suite.T().Log("About to run line #38: r.Expr(1).Gt(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Gt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #38") } { // math_logic/comparison.yaml line #39 /* false */ var expected_ bool = false /* 1 > r.expr(2) */ suite.T().Log("About to run line #39: r.Gt(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Gt(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #39") } { // math_logic/comparison.yaml line #40 /* false */ var expected_ bool = false /* r.expr(1).gt(2) */ suite.T().Log("About to run line #40: r.Expr(1).Gt(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Gt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #40") } { // math_logic/comparison.yaml line #45 /* true */ var expected_ bool = true /* r.expr(3) > 2 */ suite.T().Log("About to run line #45: r.Expr(3).Gt(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Gt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #45") } { // math_logic/comparison.yaml line #49 /* false */ var expected_ bool = false /* r.expr(2) > 2 */ suite.T().Log("About to run line #49: r.Expr(2).Gt(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Gt(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #49") } { // math_logic/comparison.yaml line #63 /* false */ var expected_ bool = false /* r.expr(1) == 2 */ suite.T().Log("About to run line #63: r.Expr(1).Eq(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Eq(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #63") } { // math_logic/comparison.yaml line #64 /* false */ var expected_ bool = false /* 1 == r.expr(2) */ suite.T().Log("About to run line #64: r.Eq(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Eq(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #64") } { // math_logic/comparison.yaml line #65 /* false */ var expected_ bool = false /* r.expr(1).eq(2) */ suite.T().Log("About to run line #65: r.Expr(1).Eq(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Eq(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #65") } { // math_logic/comparison.yaml line #68 /* false */ var expected_ bool = false /* r.expr(3) == 2 */ suite.T().Log("About to run line #68: r.Expr(3).Eq(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Eq(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #68") } { // math_logic/comparison.yaml line #72 /* true */ var expected_ bool = true /* r.expr(2) == 2 */ suite.T().Log("About to run line #72: r.Expr(2).Eq(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Eq(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #72") } { // math_logic/comparison.yaml line #86 /* true */ var expected_ bool = true /* r.expr(1) != 2 */ suite.T().Log("About to run line #86: r.Expr(1).Ne(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ne(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #86") } { // math_logic/comparison.yaml line #87 /* true */ var expected_ bool = true /* 1 != r.expr(2) */ suite.T().Log("About to run line #87: r.Ne(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Ne(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #87") } { // math_logic/comparison.yaml line #88 /* true */ var expected_ bool = true /* r.expr(1).ne(2) */ suite.T().Log("About to run line #88: r.Expr(1).Ne(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ne(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #88") } { // math_logic/comparison.yaml line #91 /* true */ var expected_ bool = true /* r.expr(3) != 2 */ suite.T().Log("About to run line #91: r.Expr(3).Ne(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Ne(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #91") } { // math_logic/comparison.yaml line #95 /* false */ var expected_ bool = false /* r.expr(2) != 2 */ suite.T().Log("About to run line #95: r.Expr(2).Ne(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Ne(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #95") } { // math_logic/comparison.yaml line #109 /* true */ var expected_ bool = true /* r.expr(1) <= 2 */ suite.T().Log("About to run line #109: r.Expr(1).Le(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Le(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #109") } { // math_logic/comparison.yaml line #110 /* true */ var expected_ bool = true /* 1 <= r.expr(2) */ suite.T().Log("About to run line #110: r.Le(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Le(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #110") } { // math_logic/comparison.yaml line #111 /* true */ var expected_ bool = true /* r.expr(1).le(2) */ suite.T().Log("About to run line #111: r.Expr(1).Le(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Le(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #111") } { // math_logic/comparison.yaml line #116 /* false */ var expected_ bool = false /* r.expr(3) <= 2 */ suite.T().Log("About to run line #116: r.Expr(3).Le(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Le(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #116") } { // math_logic/comparison.yaml line #120 /* true */ var expected_ bool = true /* r.expr(2) <= 2 */ suite.T().Log("About to run line #120: r.Expr(2).Le(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Le(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #120") } { // math_logic/comparison.yaml line #134 /* false */ var expected_ bool = false /* r.expr(1) >= 2 */ suite.T().Log("About to run line #134: r.Expr(1).Ge(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ge(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #134") } { // math_logic/comparison.yaml line #135 /* false */ var expected_ bool = false /* 1 >= r.expr(2) */ suite.T().Log("About to run line #135: r.Ge(1, r.Expr(2))") runAndAssert(suite.Suite, expected_, r.Ge(1, r.Expr(2)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #135") } { // math_logic/comparison.yaml line #136 /* false */ var expected_ bool = false /* r.expr(1).ge(2) */ suite.T().Log("About to run line #136: r.Expr(1).Ge(2)") runAndAssert(suite.Suite, expected_, r.Expr(1).Ge(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #136") } { // math_logic/comparison.yaml line #141 /* true */ var expected_ bool = true /* r.expr(3) >= 2 */ suite.T().Log("About to run line #141: r.Expr(3).Ge(2)") runAndAssert(suite.Suite, expected_, r.Expr(3).Ge(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #141") } { // math_logic/comparison.yaml line #145 /* true */ var expected_ bool = true /* r.expr(2) >= 2 */ suite.T().Log("About to run line #145: r.Expr(2).Ge(2)") runAndAssert(suite.Suite, expected_, r.Expr(2).Ge(2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #145") } { // math_logic/comparison.yaml line #158 /* true */ var expected_ bool = true /* r.expr(null) == null */ suite.T().Log("About to run line #158: r.Expr(nil).Eq(nil)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Eq(nil), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #158") } { // math_logic/comparison.yaml line #159 /* true */ var expected_ bool = true /* null == r.expr(null) */ suite.T().Log("About to run line #159: r.Eq(nil, r.Expr(nil))") runAndAssert(suite.Suite, expected_, r.Eq(nil, r.Expr(nil)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #159") } { // math_logic/comparison.yaml line #164 /* false */ var expected_ bool = false /* r.expr(null) < null */ suite.T().Log("About to run line #164: r.Expr(nil).Lt(nil)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(nil), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #164") } { // math_logic/comparison.yaml line #165 /* false */ var expected_ bool = false /* null < r.expr(null) */ suite.T().Log("About to run line #165: r.Lt(nil, r.Expr(nil))") runAndAssert(suite.Suite, expected_, r.Lt(nil, r.Expr(nil)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #165") } { // math_logic/comparison.yaml line #166 /* false */ var expected_ bool = false /* r.expr(null).lt(null) */ suite.T().Log("About to run line #166: r.Expr(nil).Lt(nil)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(nil), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #166") } { // math_logic/comparison.yaml line #172 /* false */ var expected_ bool = false /* r.expr(null) > null */ suite.T().Log("About to run line #172: r.Expr(nil).Gt(nil)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt(nil), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #172") } { // math_logic/comparison.yaml line #173 /* false */ var expected_ bool = false /* null > r.expr(null) */ suite.T().Log("About to run line #173: r.Gt(nil, r.Expr(nil))") runAndAssert(suite.Suite, expected_, r.Gt(nil, r.Expr(nil)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #173") } { // math_logic/comparison.yaml line #174 /* false */ var expected_ bool = false /* r.expr(null).gt(null) */ suite.T().Log("About to run line #174: r.Expr(nil).Gt(nil)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt(nil), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #174") } { // math_logic/comparison.yaml line #180 /* true */ var expected_ bool = true /* r.expr('a') == 'a' */ suite.T().Log("About to run line #180: r.Expr('a').Eq('a')") runAndAssert(suite.Suite, expected_, r.Expr("a").Eq("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #180") } { // math_logic/comparison.yaml line #184 /* false */ var expected_ bool = false /* r.expr('a') == 'aa' */ suite.T().Log("About to run line #184: r.Expr('a').Eq('aa')") runAndAssert(suite.Suite, expected_, r.Expr("a").Eq("aa"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #184") } { // math_logic/comparison.yaml line #188 /* true */ var expected_ bool = true /* r.expr('a') < 'aa' */ suite.T().Log("About to run line #188: r.Expr('a').Lt('aa')") runAndAssert(suite.Suite, expected_, r.Expr("a").Lt("aa"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #188") } { // math_logic/comparison.yaml line #192 /* true */ var expected_ bool = true /* r.expr('a') < 'bb' */ suite.T().Log("About to run line #192: r.Expr('a').Lt('bb')") runAndAssert(suite.Suite, expected_, r.Expr("a").Lt("bb"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #192") } { // math_logic/comparison.yaml line #196 /* true */ var expected_ bool = true /* r.expr('bb') > 'a' */ suite.T().Log("About to run line #196: r.Expr('bb').Gt('a')") runAndAssert(suite.Suite, expected_, r.Expr("bb").Gt("a"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #196") } { // math_logic/comparison.yaml line #200 /* true */ var expected_ bool = true /* r.expr('abcdef') < 'abcdeg' */ suite.T().Log("About to run line #200: r.Expr('abcdef').Lt('abcdeg')") runAndAssert(suite.Suite, expected_, r.Expr("abcdef").Lt("abcdeg"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #200") } { // math_logic/comparison.yaml line #204 /* false */ var expected_ bool = false /* r.expr('abcdefg') > 'abcdeg' */ suite.T().Log("About to run line #204: r.Expr('abcdefg').Gt('abcdeg')") runAndAssert(suite.Suite, expected_, r.Expr("abcdefg").Gt("abcdeg"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #204") } { // math_logic/comparison.yaml line #208 /* true */ var expected_ bool = true /* r.expr('A quick brown fox') > 'A quick brawn fox' */ suite.T().Log("About to run line #208: r.Expr('A quick brown fox').Gt('A quick brawn fox')") runAndAssert(suite.Suite, expected_, r.Expr("A quick brown fox").Gt("A quick brawn fox"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #208") } { // math_logic/comparison.yaml line #216 /* true */ var expected_ bool = true /* r.expr([1]) < [2] */ suite.T().Log("About to run line #216: r.Expr([]interface{}{1}).Lt([]interface{}{2})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Lt([]interface{}{2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #216") } { // math_logic/comparison.yaml line #221 /* false */ var expected_ bool = false /* r.expr([1]) > [2] */ suite.T().Log("About to run line #221: r.Expr([]interface{}{1}).Gt([]interface{}{2})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Gt([]interface{}{2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #221") } { // math_logic/comparison.yaml line #226 /* true */ var expected_ bool = true /* r.expr([1, 0]) < [2] */ suite.T().Log("About to run line #226: r.Expr([]interface{}{1, 0}).Lt([]interface{}{2})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Lt([]interface{}{2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #226") } { // math_logic/comparison.yaml line #231 /* false */ var expected_ bool = false /* r.expr([1, 0]) < [1] */ suite.T().Log("About to run line #231: r.Expr([]interface{}{1, 0}).Lt([]interface{}{1})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Lt([]interface{}{1}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #231") } { // math_logic/comparison.yaml line #236 /* true */ var expected_ bool = true /* r.expr([1, 0]) > [0] */ suite.T().Log("About to run line #236: r.Expr([]interface{}{1, 0}).Gt([]interface{}{0})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Gt([]interface{}{0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #236") } { // math_logic/comparison.yaml line #241 /* true */ var expected_ bool = true /* r.expr([1, 'a']) < [1, 'b'] */ suite.T().Log("About to run line #241: r.Expr([]interface{}{1, 'a'}).Lt([]interface{}{1, 'b'})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, "a"}).Lt([]interface{}{1, "b"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #241") } { // math_logic/comparison.yaml line #246 /* true */ var expected_ bool = true /* r.expr([0, 'z']) < [1, 'b'] */ suite.T().Log("About to run line #246: r.Expr([]interface{}{0, 'z'}).Lt([]interface{}{1, 'b'})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{0, "z"}).Lt([]interface{}{1, "b"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #246") } { // math_logic/comparison.yaml line #251 /* false */ var expected_ bool = false /* r.expr([1, 1, 1]) < [1, 0, 2] */ suite.T().Log("About to run line #251: r.Expr([]interface{}{1, 1, 1}).Lt([]interface{}{1, 0, 2})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 1, 1}).Lt([]interface{}{1, 0, 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #251") } { // math_logic/comparison.yaml line #256 /* true */ var expected_ bool = true /* r.expr([1, 0, 2]) < [1, 1, 1] */ suite.T().Log("About to run line #256: r.Expr([]interface{}{1, 0, 2}).Lt([]interface{}{1, 1, 1})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0, 2}).Lt([]interface{}{1, 1, 1}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #256") } { // math_logic/comparison.yaml line #263 /* true */ var expected_ bool = true /* r.expr({'a':0}) == {'a':0} */ suite.T().Log("About to run line #263: r.Expr(map[interface{}]interface{}{'a': 0, }).Eq(map[interface{}]interface{}{'a': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0}).Eq(map[interface{}]interface{}{"a": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #263") } { // math_logic/comparison.yaml line #267 /* true */ var expected_ bool = true /* r.expr({'a':0, 'b':1}) == {'b':1, 'a':0} */ suite.T().Log("About to run line #267: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1}).Eq(map[interface{}]interface{}{"b": 1, "a": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #267") } { // math_logic/comparison.yaml line #271 /* false */ var expected_ bool = false /* r.expr({'a':0, 'b':1, 'c':2}) == {'b':1, 'a':0} */ suite.T().Log("About to run line #271: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Eq(map[interface{}]interface{}{"b": 1, "a": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #271") } { // math_logic/comparison.yaml line #275 /* false */ var expected_ bool = false /* r.expr({'a':0, 'b':1}) == {'b':1, 'a':0, 'c':2} */ suite.T().Log("About to run line #275: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1}).Eq(map[interface{}]interface{}{"b": 1, "a": 0, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #275") } { // math_logic/comparison.yaml line #279 /* false */ var expected_ bool = false /* r.expr({'a':0, 'b':1, 'd':2}) == {'b':1, 'a':0, 'c':2} */ suite.T().Log("About to run line #279: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'd': 2, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "d": 2}).Eq(map[interface{}]interface{}{"b": 1, "a": 0, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #279") } { // math_logic/comparison.yaml line #283 /* true */ var expected_ bool = true /* r.expr({'a':0}) < {'b':0} */ suite.T().Log("About to run line #283: r.Expr(map[interface{}]interface{}{'a': 0, }).Lt(map[interface{}]interface{}{'b': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #283") } { // math_logic/comparison.yaml line #287 /* true */ var expected_ bool = true /* r.expr({'a':1}) < {'b':0} */ suite.T().Log("About to run line #287: r.Expr(map[interface{}]interface{}{'a': 1, }).Lt(map[interface{}]interface{}{'b': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 1}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #287") } { // math_logic/comparison.yaml line #291 /* false */ var expected_ bool = false /* r.expr({'b':1}) < {'b':0} */ suite.T().Log("About to run line #291: r.Expr(map[interface{}]interface{}{'b': 1, }).Lt(map[interface{}]interface{}{'b': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"b": 1}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #291") } { // math_logic/comparison.yaml line #295 /* false */ var expected_ bool = false /* r.expr({'b':1}) < {'a':0} */ suite.T().Log("About to run line #295: r.Expr(map[interface{}]interface{}{'b': 1, }).Lt(map[interface{}]interface{}{'a': 0, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"b": 1}).Lt(map[interface{}]interface{}{"a": 0}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #295") } { // math_logic/comparison.yaml line #299 /* false */ var expected_ bool = false /* r.expr({'a':0, 'b':1, 'c':2}) < {'a':0, 'b':1, 'c':2} */ suite.T().Log("About to run line #299: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #299") } { // math_logic/comparison.yaml line #303 /* false */ var expected_ bool = false /* r.expr({'a':0, 'b':1, 'c':2, 'd':3}) < {'a':0, 'b':1, 'c':2} */ suite.T().Log("About to run line #303: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, 'd': 3, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2, "d": 3}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #303") } { // math_logic/comparison.yaml line #307 /* true */ var expected_ bool = true /* r.expr({'a':0, 'b':1, 'c':2}) < {'a':0, 'b':1, 'c':2, 'd':3} */ suite.T().Log("About to run line #307: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, 'd': 3, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2, "d": 3}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #307") } { // math_logic/comparison.yaml line #311 /* false */ var expected_ bool = false /* r.expr({'a':0, 'c':2}) < {'a':0, 'b':1, 'c':2} */ suite.T().Log("About to run line #311: r.Expr(map[interface{}]interface{}{'a': 0, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #311") } { // math_logic/comparison.yaml line #315 /* true */ var expected_ bool = true /* r.expr({'a':0, 'c':2}) > {'a':0, 'b':1, 'c':2} */ suite.T().Log("About to run line #315: r.Expr(map[interface{}]interface{}{'a': 0, 'c': 2, }).Gt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })") runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "c": 2}).Gt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #315") } // math_logic/comparison.yaml line #331 // everything = r.expr([[],r.now(),r.binary(b"\x00"),false,null,-5,{},"a",r.maxval]) suite.T().Log("Possibly executing: var everything r.Term = r.Expr([]interface{}{[]interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, 'a', r.MaxVal})") everything := r.Expr([]interface{}{[]interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, "a", r.MaxVal}) _ = everything // Prevent any noused variable errors { // math_logic/comparison.yaml line #336 /* true */ var expected_ bool = true /* r.and_(r.args(everything.map(r.lt(r.minval, r.row)))) */ suite.T().Log("About to run line #336: r.And(r.Args(everything.Map(r.Lt(r.MinVal, r.Row))))") runAndAssert(suite.Suite, expected_, r.And(r.Args(everything.Map(r.Lt(r.MinVal, r.Row)))), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #336") } { // math_logic/comparison.yaml line #341 /* false */ var expected_ bool = false /* r.or_(r.args(everything.map(r.gt(r.minval, r.row)))) */ suite.T().Log("About to run line #341: r.Or(r.Args(everything.Map(r.Gt(r.MinVal, r.Row))))") runAndAssert(suite.Suite, expected_, r.Or(r.Args(everything.Map(r.Gt(r.MinVal, r.Row)))), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #341") } { // math_logic/comparison.yaml line #345 /* true */ var expected_ bool = true /* r.eq(r.minval, r.minval) */ suite.T().Log("About to run line #345: r.Eq(r.MinVal, r.MinVal)") runAndAssert(suite.Suite, expected_, r.Eq(r.MinVal, r.MinVal), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #345") } { // math_logic/comparison.yaml line #348 /* true */ var expected_ bool = true /* r.expr([]) < True */ suite.T().Log("About to run line #348: r.Expr([]interface{}{}).Lt(true)") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Lt(true), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #348") } { // math_logic/comparison.yaml line #353 /* true */ var expected_ bool = true /* r.expr([1,2]) < False */ suite.T().Log("About to run line #353: r.Expr([]interface{}{1, 2}).Lt(false)") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 2}).Lt(false), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #353") } { // math_logic/comparison.yaml line #358 /* false */ var expected_ bool = false /* r.expr(False) < [] */ suite.T().Log("About to run line #358: r.Expr(false).Lt([]interface{}{})") runAndAssert(suite.Suite, expected_, r.Expr(false).Lt([]interface{}{}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #358") } { // math_logic/comparison.yaml line #363 /* true */ var expected_ bool = true /* r.expr([]) < r.binary(b"\xAE") */ suite.T().Log("About to run line #363: r.Expr([]interface{}{}).Lt(r.Binary([]byte{174}))") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Lt(r.Binary([]byte{174})), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #363") } { // math_logic/comparison.yaml line #368 /* true */ var expected_ bool = true /* r.expr([1,2]) < r.binary(b"\xAE") */ suite.T().Log("About to run line #368: r.Expr([]interface{}{1, 2}).Lt(r.Binary([]byte{174}))") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 2}).Lt(r.Binary([]byte{174})), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #368") } { // math_logic/comparison.yaml line #373 /* true */ var expected_ bool = true /* True < r.expr(null) */ suite.T().Log("About to run line #373: r.Lt(true, r.Expr(nil))") runAndAssert(suite.Suite, expected_, r.Lt(true, r.Expr(nil)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #373") } { // math_logic/comparison.yaml line #378 /* true */ var expected_ bool = true /* r.expr(null) > [] */ suite.T().Log("About to run line #378: r.Expr(nil).Gt([]interface{}{})") runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt([]interface{}{}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #378") } { // math_logic/comparison.yaml line #383 /* true */ var expected_ bool = true /* r.expr(null) < 12 */ suite.T().Log("About to run line #383: r.Expr(nil).Lt(12)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(12), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #383") } { // math_logic/comparison.yaml line #388 /* true */ var expected_ bool = true /* r.expr(null) < -2 */ suite.T().Log("About to run line #388: r.Expr(nil).Lt(-2)") runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(-2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #388") } { // math_logic/comparison.yaml line #393 /* true */ var expected_ bool = true /* r.expr(-12) < {} */ suite.T().Log("About to run line #393: r.Expr(-12).Lt(map[interface{}]interface{}{})") runAndAssert(suite.Suite, expected_, r.Expr(-12).Lt(map[interface{}]interface{}{}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #393") } { // math_logic/comparison.yaml line #398 /* true */ var expected_ bool = true /* r.expr(100) < {'a':-12} */ suite.T().Log("About to run line #398: r.Expr(100).Lt(map[interface{}]interface{}{'a': -12, })") runAndAssert(suite.Suite, expected_, r.Expr(100).Lt(map[interface{}]interface{}{"a": -12}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #398") } { // math_logic/comparison.yaml line #403 /* false */ var expected_ bool = false /* r.expr(r.binary(b"\xAE")) < 12 */ suite.T().Log("About to run line #403: r.Expr(r.Binary([]byte{174})).Lt(12)") runAndAssert(suite.Suite, expected_, r.Expr(r.Binary([]byte{174})).Lt(12), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #403") } { // math_logic/comparison.yaml line #408 /* true */ var expected_ bool = true /* r.binary(b"0xAE") < 'abc' */ suite.T().Log("About to run line #408: r.Binary([]byte{48,120,65,69}).Lt('abc')") runAndAssert(suite.Suite, expected_, r.Binary([]byte{48, 120, 65, 69}).Lt("abc"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #408") } { // math_logic/comparison.yaml line #413 /* false */ var expected_ bool = false /* r.binary(b"0xAE") > r.now() */ suite.T().Log("About to run line #413: r.Binary([]byte{48,120,65,69}).Gt(r.Now())") runAndAssert(suite.Suite, expected_, r.Binary([]byte{48, 120, 65, 69}).Gt(r.Now()), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #413") } { // math_logic/comparison.yaml line #418 /* true */ var expected_ bool = true /* r.now() > 12 */ suite.T().Log("About to run line #418: r.Now().Gt(12)") runAndAssert(suite.Suite, expected_, r.Now().Gt(12), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #418") } { // math_logic/comparison.yaml line #422 /* false */ var expected_ bool = false /* r.now() > 'abc' */ suite.T().Log("About to run line #422: r.Now().Gt('abc')") runAndAssert(suite.Suite, expected_, r.Now().Gt("abc"), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #422") } { // math_logic/comparison.yaml line #426 /* true */ var expected_ bool = true /* r.expr("abc") > {'a':-12} */ suite.T().Log("About to run line #426: r.Expr('abc').Gt(map[interface{}]interface{}{'a': -12, })") runAndAssert(suite.Suite, expected_, r.Expr("abc").Gt(map[interface{}]interface{}{"a": -12}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #426") } { // math_logic/comparison.yaml line #431 /* true */ var expected_ bool = true /* r.expr("abc") > {'abc':'abc'} */ suite.T().Log("About to run line #431: r.Expr('abc').Gt(map[interface{}]interface{}{'abc': 'abc', })") runAndAssert(suite.Suite, expected_, r.Expr("abc").Gt(map[interface{}]interface{}{"abc": "abc"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #431") } { // math_logic/comparison.yaml line #436 /* true */ var expected_ bool = true /* r.expr('zzz') > 128 */ suite.T().Log("About to run line #436: r.Expr('zzz').Gt(128)") runAndAssert(suite.Suite, expected_, r.Expr("zzz").Gt(128), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #436") } { // math_logic/comparison.yaml line #441 /* true */ var expected_ bool = true /* r.expr('zzz') > {} */ suite.T().Log("About to run line #441: r.Expr('zzz').Gt(map[interface{}]interface{}{})") runAndAssert(suite.Suite, expected_, r.Expr("zzz").Gt(map[interface{}]interface{}{}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #441") } { // math_logic/comparison.yaml line #446 /* true */ var expected_ bool = true /* 'zzz' > r.expr(-152) */ suite.T().Log("About to run line #446: r.Gt('zzz', r.Expr(-152))") runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr(-152)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #446") } { // math_logic/comparison.yaml line #451 /* true */ var expected_ bool = true /* 'zzz' > r.expr(null) */ suite.T().Log("About to run line #451: r.Gt('zzz', r.Expr(nil))") runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr(nil)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #451") } { // math_logic/comparison.yaml line #456 /* true */ var expected_ bool = true /* 'zzz' > r.expr([]) */ suite.T().Log("About to run line #456: r.Gt('zzz', r.Expr([]interface{}{}))") runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr([]interface{}{})), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #456") } // math_logic/comparison.yaml line #463 // everything2 = r.expr([r.minval,[],r.now(),r.binary(b"\x00"),false,null,-5,{},"a"]) suite.T().Log("Possibly executing: var everything2 r.Term = r.Expr([]interface{}{r.MinVal, []interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, 'a'})") everything2 := r.Expr([]interface{}{r.MinVal, []interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, "a"}) _ = everything2 // Prevent any noused variable errors { // math_logic/comparison.yaml line #467 /* true */ var expected_ bool = true /* r.and_(r.args(everything2.map(r.gt(r.maxval, r.row)))) */ suite.T().Log("About to run line #467: r.And(r.Args(everything2.Map(r.Gt(r.MaxVal, r.Row))))") runAndAssert(suite.Suite, expected_, r.And(r.Args(everything2.Map(r.Gt(r.MaxVal, r.Row)))), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #467") } { // math_logic/comparison.yaml line #472 /* false */ var expected_ bool = false /* r.or_(r.args(everything2.map(r.lt(r.maxval, r.row)))) */ suite.T().Log("About to run line #472: r.Or(r.Args(everything2.Map(r.Lt(r.MaxVal, r.Row))))") runAndAssert(suite.Suite, expected_, r.Or(r.Args(everything2.Map(r.Lt(r.MaxVal, r.Row)))), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #472") } { // math_logic/comparison.yaml line #476 /* true */ var expected_ bool = true /* r.eq(r.maxval, r.maxval) */ suite.T().Log("About to run line #476: r.Eq(r.MaxVal, r.MaxVal)") runAndAssert(suite.Suite, expected_, r.Eq(r.MaxVal, r.MaxVal), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #476") } }
func (suite *TimesApiSuite) TestCases() { suite.T().Log("Running TimesApiSuite: date/time api (#977)") // times/api.yaml line #6 // rt1 = 1375147296.6812 suite.T().Log("Possibly executing: var rt1 float64 = 1375147296.6812") rt1 := 1375147296.6812 _ = rt1 // Prevent any noused variable errors // times/api.yaml line #7 // t1 = r.epoch_time(rt1) suite.T().Log("Possibly executing: var t1 r.Term = r.EpochTime(rt1)") t1 := r.EpochTime(rt1) _ = t1 // Prevent any noused variable errors // times/api.yaml line #8 // t2 = r.epoch_time(rt1 + 1000) suite.T().Log("Possibly executing: var t2 r.Term = r.EpochTime(r.Add(rt1, 1000))") t2 := r.EpochTime(r.Add(rt1, 1000)) _ = t2 // Prevent any noused variable errors { // times/api.yaml line #11 /* (1375148296.681) */ var expected_ float64 = 1375148296.681 /* (t1 + 1000).to_epoch_time() */ suite.T().Log("About to run line #11: r.Add(t1, 1000).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Add(t1, 1000).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #11") } { // times/api.yaml line #14 /* (1375146296.681) */ var expected_ float64 = 1375146296.681 /* (t1 - 1000).to_epoch_time() */ suite.T().Log("About to run line #14: r.Sub(t1, 1000).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Sub(t1, 1000).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #14") } { // times/api.yaml line #17 /* 1000 */ var expected_ int = 1000 /* (t1 - (t1 - 1000)) */ suite.T().Log("About to run line #17: r.Sub(t1, r.Sub(t1, 1000))") runAndAssert(suite.Suite, expected_, r.Sub(t1, r.Sub(t1, 1000)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #17") } { // times/api.yaml line #22 /* false */ var expected_ bool = false /* (t1 < t1) */ suite.T().Log("About to run line #22: r.Lt(t1, t1)") runAndAssert(suite.Suite, expected_, r.Lt(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #22") } { // times/api.yaml line #25 /* true */ var expected_ bool = true /* (t1 <= t1) */ suite.T().Log("About to run line #25: r.Le(t1, t1)") runAndAssert(suite.Suite, expected_, r.Le(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #25") } { // times/api.yaml line #29 /* true */ var expected_ bool = true /* (t1 == t1) */ suite.T().Log("About to run line #29: r.Eq(t1, t1)") runAndAssert(suite.Suite, expected_, r.Eq(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #29") } { // times/api.yaml line #32 /* false */ var expected_ bool = false /* (t1 != t1) */ suite.T().Log("About to run line #32: r.Ne(t1, t1)") runAndAssert(suite.Suite, expected_, r.Ne(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #32") } { // times/api.yaml line #34 /* true */ var expected_ bool = true /* (t1 >= t1) */ suite.T().Log("About to run line #34: r.Ge(t1, t1)") runAndAssert(suite.Suite, expected_, r.Ge(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #34") } { // times/api.yaml line #37 /* false */ var expected_ bool = false /* (t1 > t1) */ suite.T().Log("About to run line #37: r.Gt(t1, t1)") runAndAssert(suite.Suite, expected_, r.Gt(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #37") } { // times/api.yaml line #40 /* true */ var expected_ bool = true /* (t1 < t2) */ suite.T().Log("About to run line #40: r.Lt(t1, t2)") runAndAssert(suite.Suite, expected_, r.Lt(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #40") } { // times/api.yaml line #43 /* true */ var expected_ bool = true /* (t1 <= t2) */ suite.T().Log("About to run line #43: r.Le(t1, t2)") runAndAssert(suite.Suite, expected_, r.Le(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #43") } { // times/api.yaml line #47 /* false */ var expected_ bool = false /* (t1 == t2) */ suite.T().Log("About to run line #47: r.Eq(t1, t2)") runAndAssert(suite.Suite, expected_, r.Eq(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #47") } { // times/api.yaml line #50 /* true */ var expected_ bool = true /* (t1 != t2) */ suite.T().Log("About to run line #50: r.Ne(t1, t2)") runAndAssert(suite.Suite, expected_, r.Ne(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #50") } { // times/api.yaml line #52 /* false */ var expected_ bool = false /* (t1 >= t2) */ suite.T().Log("About to run line #52: r.Ge(t1, t2)") runAndAssert(suite.Suite, expected_, r.Ge(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #52") } { // times/api.yaml line #55 /* false */ var expected_ bool = false /* (t1 > t2) */ suite.T().Log("About to run line #55: r.Gt(t1, t2)") runAndAssert(suite.Suite, expected_, r.Gt(t1, t2), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #55") } { // times/api.yaml line #60 /* true */ var expected_ bool = true /* t1.during(t1, t1 + 1000) */ suite.T().Log("About to run line #60: t1.During(t1, r.Add(t1, 1000))") runAndAssert(suite.Suite, expected_, t1.During(t1, r.Add(t1, 1000)), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #60") } { // times/api.yaml line #64 /* false */ var expected_ bool = false /* t1.during(t1, t1 + 1000, left_bound='open') */ suite.T().Log("About to run line #64: t1.During(t1, r.Add(t1, 1000)).OptArgs(r.DuringOpts{LeftBound: 'open', })") runAndAssert(suite.Suite, expected_, t1.During(t1, r.Add(t1, 1000)).OptArgs(r.DuringOpts{LeftBound: "open"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #64") } { // times/api.yaml line #67 /* false */ var expected_ bool = false /* t1.during(t1, t1) */ suite.T().Log("About to run line #67: t1.During(t1, t1)") runAndAssert(suite.Suite, expected_, t1.During(t1, t1), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #67") } { // times/api.yaml line #70 /* true */ var expected_ bool = true /* t1.during(t1, t1, right_bound='closed') */ suite.T().Log("About to run line #70: t1.During(t1, t1).OptArgs(r.DuringOpts{RightBound: 'closed', })") runAndAssert(suite.Suite, expected_, t1.During(t1, t1).OptArgs(r.DuringOpts{RightBound: "closed"}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #70") } { // times/api.yaml line #77 /* 1375142400 */ var expected_ int = 1375142400 /* t1.date().to_epoch_time() */ suite.T().Log("About to run line #77: t1.Date().ToEpochTime()") runAndAssert(suite.Suite, expected_, t1.Date().ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #77") } { // times/api.yaml line #79 /* (4896.681) */ var expected_ float64 = 4896.681 /* t1.time_of_day() */ suite.T().Log("About to run line #79: t1.TimeOfDay()") runAndAssert(suite.Suite, expected_, t1.TimeOfDay(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #79") } { // times/api.yaml line #81 /* 2013 */ var expected_ int = 2013 /* t1.year() */ suite.T().Log("About to run line #81: t1.Year()") runAndAssert(suite.Suite, expected_, t1.Year(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #81") } { // times/api.yaml line #83 /* 7 */ var expected_ int = 7 /* t1.month() */ suite.T().Log("About to run line #83: t1.Month()") runAndAssert(suite.Suite, expected_, t1.Month(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #83") } { // times/api.yaml line #85 /* 30 */ var expected_ int = 30 /* t1.day() */ suite.T().Log("About to run line #85: t1.Day()") runAndAssert(suite.Suite, expected_, t1.Day(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #85") } { // times/api.yaml line #87 /* 2 */ var expected_ int = 2 /* t1.day_of_week() */ suite.T().Log("About to run line #87: t1.DayOfWeek()") runAndAssert(suite.Suite, expected_, t1.DayOfWeek(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #87") } { // times/api.yaml line #89 /* 211 */ var expected_ int = 211 /* t1.day_of_year() */ suite.T().Log("About to run line #89: t1.DayOfYear()") runAndAssert(suite.Suite, expected_, t1.DayOfYear(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #89") } { // times/api.yaml line #91 /* 1 */ var expected_ int = 1 /* t1.hours() */ suite.T().Log("About to run line #91: t1.Hours()") runAndAssert(suite.Suite, expected_, t1.Hours(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #91") } { // times/api.yaml line #93 /* 21 */ var expected_ int = 21 /* t1.minutes() */ suite.T().Log("About to run line #93: t1.Minutes()") runAndAssert(suite.Suite, expected_, t1.Minutes(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #93") } { // times/api.yaml line #95 /* 36.681 */ var expected_ float64 = 36.681 /* t1.seconds() */ suite.T().Log("About to run line #95: t1.Seconds()") runAndAssert(suite.Suite, expected_, t1.Seconds(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #95") } { // times/api.yaml line #99 /* (1375165800.1) */ var expected_ float64 = 1375165800.1 /* r.time(2013, r.july, 29, 23, 30, 0.1, "-07:00").to_epoch_time() */ suite.T().Log("About to run line #99: r.Time(2013, r.July, 29, 23, 30, 0.1, '-07:00').ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23, 30, 0.1, "-07:00").ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #99") } { // times/api.yaml line #101 /* ("-07:00") */ var expected_ string = "-07:00" /* r.time(2013, r.july, 29, 23, 30, 0.1, "-07:00").timezone() */ suite.T().Log("About to run line #101: r.Time(2013, r.July, 29, 23, 30, 0.1, '-07:00').Timezone()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23, 30, 0.1, "-07:00").Timezone(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #101") } { // times/api.yaml line #103 /* err("ReqlQueryLogicError", "Got 6 arguments to TIME (expected 4 or 7).", []) */ var expected_ Err = err("ReqlQueryLogicError", "Got 6 arguments to TIME (expected 4 or 7).") /* r.time(2013, r.july, 29, 23, 30, 0.1).to_epoch_time() */ suite.T().Log("About to run line #103: r.Time(2013, r.July, 29, 23, 30, 0.1).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23, 30, 0.1).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #103") } { // times/api.yaml line #105 /* err("ReqlQueryLogicError", "Got 6 arguments to TIME (expected 4 or 7).", []) */ var expected_ Err = err("ReqlQueryLogicError", "Got 6 arguments to TIME (expected 4 or 7).") /* r.time(2013, r.july, 29, 23, 30, 0.1).timezone() */ suite.T().Log("About to run line #105: r.Time(2013, r.July, 29, 23, 30, 0.1).Timezone()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23, 30, 0.1).Timezone(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #105") } { // times/api.yaml line #107 /* err("ReqlQueryLogicError", "Got 5 arguments to TIME (expected 4 or 7).", []) */ var expected_ Err = err("ReqlQueryLogicError", "Got 5 arguments to TIME (expected 4 or 7).") /* r.time(2013, r.july, 29, 23, 30).to_epoch_time() */ suite.T().Log("About to run line #107: r.Time(2013, r.July, 29, 23, 30).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23, 30).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #107") } { // times/api.yaml line #109 /* err("ReqlQueryLogicError", "Expected type STRING but found NUMBER.", []) */ var expected_ Err = err("ReqlQueryLogicError", "Expected type STRING but found NUMBER.") /* r.time(2013, r.july, 29, 23).to_epoch_time() */ suite.T().Log("About to run line #109: r.Time(2013, r.July, 29, 23).ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, 23).ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #109") } { // times/api.yaml line #111 /* 1375081200 */ var expected_ int = 1375081200 /* r.time(2013, r.july, 29, "-07:00").to_epoch_time() */ suite.T().Log("About to run line #111: r.Time(2013, r.July, 29, '-07:00').ToEpochTime()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, "-07:00").ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #111") } { // times/api.yaml line #113 /* ("-07:00") */ var expected_ string = "-07:00" /* r.time(2013, r.july, 29, "-07:00").timezone() */ suite.T().Log("About to run line #113: r.Time(2013, r.July, 29, '-07:00').Timezone()") runAndAssert(suite.Suite, expected_, r.Time(2013, r.July, 29, "-07:00").Timezone(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #113") } { // times/api.yaml line #119 /* 1375242965 */ var expected_ int = 1375242965 /* r.iso8601("2013-07-30T20:56:05-07:00").to_epoch_time() */ suite.T().Log("About to run line #119: r.ISO8601('2013-07-30T20:56:05-07:00').ToEpochTime()") runAndAssert(suite.Suite, expected_, r.ISO8601("2013-07-30T20:56:05-07:00").ToEpochTime(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #119") } { // times/api.yaml line #122 /* ("2013-07-30T20:56:05-07:00") */ var expected_ string = "2013-07-30T20:56:05-07:00" /* r.epoch_time(1375242965).in_timezone("-07:00").to_iso8601() */ suite.T().Log("About to run line #122: r.EpochTime(1375242965).InTimezone('-07:00').ToISO8601()") runAndAssert(suite.Suite, expected_, r.EpochTime(1375242965).InTimezone("-07:00").ToISO8601(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #122") } { // times/api.yaml line #125 /* ("PTYPE<TIME>") */ var expected_ string = "PTYPE<TIME>" /* r.now().type_of() */ suite.T().Log("About to run line #125: r.Now().TypeOf()") runAndAssert(suite.Suite, expected_, r.Now().TypeOf(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #125") } { // times/api.yaml line #127 /* 0 */ var expected_ int = 0 /* (r.now() - r.now()) */ suite.T().Log("About to run line #127: r.Now().Sub(r.Now())") runAndAssert(suite.Suite, expected_, r.Now().Sub(r.Now()), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #127") } { // times/api.yaml line #132 /* err("ReqlQueryLogicError", "ISO 8601 string has no time zone, and no default time zone was provided.", []) */ var expected_ Err = err("ReqlQueryLogicError", "ISO 8601 string has no time zone, and no default time zone was provided.") /* r.iso8601("2013-07-30T20:56:05").to_iso8601() */ suite.T().Log("About to run line #132: r.ISO8601('2013-07-30T20:56:05').ToISO8601()") runAndAssert(suite.Suite, expected_, r.ISO8601("2013-07-30T20:56:05").ToISO8601(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #132") } { // times/api.yaml line #136 /* ("2013-07-30T20:56:05-07:00") */ var expected_ string = "2013-07-30T20:56:05-07:00" /* r.iso8601("2013-07-30T20:56:05", default_timezone='-07').to_iso8601() */ suite.T().Log("About to run line #136: r.ISO8601('2013-07-30T20:56:05').OptArgs(r.ISO8601Opts{DefaultTimezone: '-07', }).ToISO8601()") runAndAssert(suite.Suite, expected_, r.ISO8601("2013-07-30T20:56:05").OptArgs(r.ISO8601Opts{DefaultTimezone: "-07"}).ToISO8601(), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #136") } { // times/api.yaml line #140 /* ([1, 2, 3, 4, 5, 6, 7]) */ var expected_ []interface{} = []interface{}{1, 2, 3, 4, 5, 6, 7} /* r.expr([r.monday, r.tuesday, r.wednesday, r.thursday, r.friday, r.saturday, r.sunday]) */ suite.T().Log("About to run line #140: r.Expr([]interface{}{r.Monday, r.Tuesday, r.Wednesday, r.Thursday, r.Friday, r.Saturday, r.Sunday})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{r.Monday, r.Tuesday, r.Wednesday, r.Thursday, r.Friday, r.Saturday, r.Sunday}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #140") } { // times/api.yaml line #142 /* ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) */ var expected_ []interface{} = []interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12} /* r.expr([r.january, r.february, r.march, r.april, r.may, r.june, r.july, r.august, r.september, r.october, r.november, r.december]) */ suite.T().Log("About to run line #142: r.Expr([]interface{}{r.January, r.February, r.March, r.April, r.May, r.June, r.July, r.August, r.September, r.October, r.November, r.December})") runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{r.January, r.February, r.March, r.April, r.May, r.June, r.July, r.August, r.September, r.October, r.November, r.December}), suite.session, r.RunOpts{ GeometryFormat: "raw", GroupFormat: "map", }) suite.T().Log("Finished running line #142") } }