func (suite *MathLogicSubSuite) TestCases() {
suite.T().Log("Running MathLogicSubSuite: Tests for basic usage of the subtraction operation")
{
// math_logic/sub.yaml line #6
/* 0 */
var expected_ int = 0
/* r.expr(1) - 1 */
suite.T().Log("About to run line #6: r.Expr(1).Sub(1)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Sub(1), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #6")
}
{
// math_logic/sub.yaml line #7
/* 0 */
var expected_ int = 0
/* 1 - r.expr(1) */
suite.T().Log("About to run line #7: r.Sub(1, r.Expr(1))")
runAndAssert(suite.Suite, expected_, r.Sub(1, r.Expr(1)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #7")
}
{
// math_logic/sub.yaml line #8
/* 0 */
var expected_ int = 0
/* r.expr(1).sub(1) */
suite.T().Log("About to run line #8: r.Expr(1).Sub(1)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Sub(1), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #8")
}
{
// math_logic/sub.yaml line #17
/* -2 */
var expected_ int = -2
/* r.expr(-1) - 1 */
suite.T().Log("About to run line #17: r.Expr(-1).Sub(1)")
runAndAssert(suite.Suite, expected_, r.Expr(-1).Sub(1), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #17")
}
{
// math_logic/sub.yaml line #22
/* -6.75 */
var expected_ float64 = -6.75
/* r.expr(1.75) - 8.5 */
suite.T().Log("About to run line #22: r.Expr(1.75).Sub(8.5)")
runAndAssert(suite.Suite, expected_, r.Expr(1.75).Sub(8.5), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #22")
}
{
// math_logic/sub.yaml line #26
/* -13 */
var expected_ int = -13
/* r.expr(1).sub(2,3,4,5) */
suite.T().Log("About to run line #26: r.Expr(1).Sub(2, 3, 4, 5)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Sub(2, 3, 4, 5), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #26")
}
{
// math_logic/sub.yaml line #30
/* err('ReqlQueryLogicError', 'Expected type NUMBER but found STRING.', [0]) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* r.expr('a').sub(0.8) */
suite.T().Log("About to run line #30: r.Expr('a').Sub(0.8)")
runAndAssert(suite.Suite, expected_, r.Expr("a").Sub(0.8), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #30")
}
{
// math_logic/sub.yaml line #33
/* err('ReqlQueryLogicError', 'Expected type NUMBER but found STRING.', [1]) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* r.expr(1).sub('a') */
suite.T().Log("About to run line #33: r.Expr(1).Sub('a')")
runAndAssert(suite.Suite, expected_, r.Expr(1).Sub("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #33")
}
{
// math_logic/sub.yaml line #36
/* err('ReqlQueryLogicError', 'Expected type NUMBER but found STRING.', [0]) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* r.expr('b').sub('a') */
suite.T().Log("About to run line #36: r.Expr('b').Sub('a')")
runAndAssert(suite.Suite, expected_, r.Expr("b").Sub("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #36")
}
}
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 *DefaultSuite) TestCases() {
suite.T().Log("Running DefaultSuite: Tests r.default")
{
// default.yaml line #3
/* 1 */
var expected_ int = 1
/* r.expr(1).default(2) */
suite.T().Log("About to run line #3: r.Expr(1).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #3")
}
{
// default.yaml line #5
/* 2 */
var expected_ int = 2
/* r.expr(null).default(2) */
suite.T().Log("About to run line #5: r.Expr(nil).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #5")
}
{
// default.yaml line #7
/* 2 */
var expected_ int = 2
/* r.expr({})['b'].default(2) */
suite.T().Log("About to run line #7: r.Expr(map[interface{}]interface{}{}).AtIndex('b').Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{}).AtIndex("b").Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #7")
}
{
// default.yaml line #10
/* 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(r.expr('a')['b']).default(2) */
suite.T().Log("About to run line #10: r.Expr(r.Expr('a').AtIndex('b')).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(r.Expr("a").AtIndex("b")).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #10")
}
{
// default.yaml line #14
/* 2 */
var expected_ int = 2
/* r.expr([]).reduce(lambda a,b:a+b).default(2) */
suite.T().Log("About to run line #14: r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #14")
}
{
// default.yaml line #18
/* 2 */
var expected_ int = 2
/* r.expr([]).union([]).reduce(lambda a,b:a+b).default(2) */
suite.T().Log("About to run line #18: r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #18")
}
{
// default.yaml line #22
/* err("ReqlQueryLogicError", "Cannot convert STRING to SEQUENCE", []) */
var expected_ Err = err("ReqlQueryLogicError", "Cannot convert STRING to SEQUENCE")
/* r.expr('a').reduce(lambda a,b:a+b).default(2) */
suite.T().Log("About to run line #22: r.Expr('a').Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr("a").Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #22")
}
{
// default.yaml line #25
/* 2 */
var expected_ int = 2
/* (r.expr(null) + 5).default(2) */
suite.T().Log("About to run line #25: r.Expr(nil).Add(5).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Add(5).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #25")
}
{
// default.yaml line #28
/* 2 */
var expected_ int = 2
/* (5 + r.expr(null)).default(2) */
suite.T().Log("About to run line #28: r.Add(5, r.Expr(nil)).Default(2)")
runAndAssert(suite.Suite, expected_, r.Add(5, r.Expr(nil)).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #28")
}
{
// default.yaml line #31
/* 2 */
var expected_ int = 2
/* (5 - r.expr(null)).default(2) */
suite.T().Log("About to run line #31: r.Sub(5, r.Expr(nil)).Default(2)")
runAndAssert(suite.Suite, expected_, r.Sub(5, r.Expr(nil)).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #31")
}
{
// default.yaml line #34
/* 2 */
var expected_ int = 2
/* (r.expr(null) - 5).default(2) */
suite.T().Log("About to run line #34: r.Expr(nil).Sub(5).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Sub(5).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #34")
}
{
// default.yaml line #37
/* err("ReqlQueryLogicError", "Expected type STRING but found NUMBER.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type STRING but found NUMBER.")
/* (r.expr('a') + 5).default(2) */
suite.T().Log("About to run line #37: r.Expr('a').Add(5).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr("a").Add(5).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #37")
}
{
// default.yaml line #40
/* err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* (5 + r.expr('a')).default(2) */
suite.T().Log("About to run line #40: r.Add(5, r.Expr('a')).Default(2)")
runAndAssert(suite.Suite, expected_, r.Add(5, r.Expr("a")).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #40")
}
{
// default.yaml line #43
/* err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* (r.expr('a') - 5).default(2) */
suite.T().Log("About to run line #43: r.Expr('a').Sub(5).Default(2)")
runAndAssert(suite.Suite, expected_, r.Expr("a").Sub(5).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #43")
}
{
// default.yaml line #46
/* err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.", []) */
var expected_ Err = err("ReqlQueryLogicError", "Expected type NUMBER but found STRING.")
/* (5 - r.expr('a')).default(2) */
suite.T().Log("About to run line #46: r.Sub(5, r.Expr('a')).Default(2)")
runAndAssert(suite.Suite, expected_, r.Sub(5, r.Expr("a")).Default(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #46")
}
{
// default.yaml line #50
/* 1 */
var expected_ int = 1
/* r.expr(1).default(r.error()) */
suite.T().Log("About to run line #50: r.Expr(1).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr(1).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #50")
}
{
// default.yaml line #52
/* (null) */
var expected_ interface{} = nil
/* r.expr(null).default(r.error()) */
suite.T().Log("About to run line #52: r.Expr(nil).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #52")
}
{
// default.yaml line #54
/* err("ReqlNonExistenceError", "No attribute `b` in object:", []) */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `b` in object:")
/* r.expr({})['b'].default(r.error()) */
suite.T().Log("About to run line #54: r.Expr(map[interface{}]interface{}{}).AtIndex('b').Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{}).AtIndex("b").Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #54")
}
{
// default.yaml line #58
/* err("ReqlNonExistenceError", "Cannot reduce over an empty stream.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Cannot reduce over an empty stream.")
/* r.expr([]).reduce(lambda a,b:a+b).default(r.error) */
suite.T().Log("About to run line #58: r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #58")
}
{
// default.yaml line #62
/* err("ReqlNonExistenceError", "Cannot reduce over an empty stream.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Cannot reduce over an empty stream.")
/* r.expr([]).union([]).reduce(lambda a,b:a+b).default(r.error) */
suite.T().Log("About to run line #62: r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #62")
}
{
// default.yaml line #65
/* err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.")
/* (r.expr(null) + 5).default(r.error) */
suite.T().Log("About to run line #65: r.Expr(nil).Add(5).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Add(5).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #65")
}
{
// default.yaml line #68
/* err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.")
/* (5 + r.expr(null)).default(r.error) */
suite.T().Log("About to run line #68: r.Add(5, r.Expr(nil)).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Add(5, r.Expr(nil)).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #68")
}
{
// default.yaml line #71
/* err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.")
/* (5 - r.expr(null)).default(r.error) */
suite.T().Log("About to run line #71: r.Sub(5, r.Expr(nil)).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Sub(5, r.Expr(nil)).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #71")
}
{
// default.yaml line #74
/* err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.", []) */
var expected_ Err = err("ReqlNonExistenceError", "Expected type NUMBER but found NULL.")
/* (r.expr(null) - 5).default(r.error) */
suite.T().Log("About to run line #74: r.Expr(nil).Sub(5).Default(r.Error())")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Sub(5).Default(r.Error()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #74")
}
{
// default.yaml line #79
/* 1 */
var expected_ int = 1
/* r.expr(1).default(lambda e:e) */
suite.T().Log("About to run line #79: r.Expr(1).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr(1).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #79")
}
{
// default.yaml line #83
/* (null) */
var expected_ interface{} = nil
/* r.expr(null).default(lambda e:e) */
suite.T().Log("About to run line #83: r.Expr(nil).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #83")
}
{
// default.yaml line #87
/* "No attribute `b` in object:\n{}" */
var expected_ string = "No attribute `b` in object:\n{}"
/* r.expr({})['b'].default(lambda e:e) */
suite.T().Log("About to run line #87: r.Expr(map[interface{}]interface{}{}).AtIndex('b').Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{}).AtIndex("b").Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #87")
}
{
// default.yaml line #91
/* ("Cannot reduce over an empty stream.") */
var expected_ string = "Cannot reduce over an empty stream."
/* r.expr([]).reduce(lambda a,b:a+b).default(lambda e:e) */
suite.T().Log("About to run line #91: r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #91")
}
{
// default.yaml line #95
/* ("Cannot reduce over an empty stream.") */
var expected_ string = "Cannot reduce over an empty stream."
/* r.expr([]).union([]).reduce(lambda a,b:a+b).default(lambda e:e) */
suite.T().Log("About to run line #95: r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b)}).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Union([]interface{}{}).Reduce(func(a r.Term, b r.Term) interface{} { return r.Add(a, b) }).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #95")
}
{
// default.yaml line #99
/* ("Expected type NUMBER but found NULL.") */
var expected_ string = "Expected type NUMBER but found NULL."
/* (r.expr(null) + 5).default(lambda e:e) */
suite.T().Log("About to run line #99: r.Expr(nil).Add(5).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Add(5).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #99")
}
{
// default.yaml line #103
/* ("Expected type NUMBER but found NULL.") */
var expected_ string = "Expected type NUMBER but found NULL."
/* (5 + r.expr(null)).default(lambda e:e) */
suite.T().Log("About to run line #103: r.Add(5, r.Expr(nil)).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Add(5, r.Expr(nil)).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #103")
}
{
// default.yaml line #107
/* ("Expected type NUMBER but found NULL.") */
var expected_ string = "Expected type NUMBER but found NULL."
/* (5 - r.expr(null)).default(lambda e:e) */
suite.T().Log("About to run line #107: r.Sub(5, r.Expr(nil)).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Sub(5, r.Expr(nil)).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #107")
}
{
// default.yaml line #111
/* ("Expected type NUMBER but found NULL.") */
var expected_ string = "Expected type NUMBER but found NULL."
/* (r.expr(null) - 5).default(lambda e:e) */
suite.T().Log("About to run line #111: r.Expr(nil).Sub(5).Default(func(e r.Term) interface{} { return e})")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Sub(5).Default(func(e r.Term) interface{} { return e }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #111")
}
// default.yaml line #115
// arr = r.expr([{'a':1},{'a':null},{}]).order_by('a')
suite.T().Log("Possibly executing: var arr r.Term = r.Expr([]interface{}{map[interface{}]interface{}{'a': 1, }, map[interface{}]interface{}{'a': nil, }, map[interface{}]interface{}{}}).OrderBy('a')")
arr := r.Expr([]interface{}{map[interface{}]interface{}{"a": 1}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{}}).OrderBy("a")
_ = arr // Prevent any noused variable errors
{
// default.yaml line #118
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].eq(1)) */
suite.T().Log("About to run line #118: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)})")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #118")
}
{
// default.yaml line #122
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].eq(1), default=False) */
suite.T().Log("About to run line #122: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: false, })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #122")
}
{
// default.yaml line #126
/* [{}, {'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].eq(1), default=True) */
suite.T().Log("About to run line #126: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: true, })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: true}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #126")
}
{
// default.yaml line #131
/* [{}, {'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].eq(1), default=r.js('true')) */
suite.T().Log("About to run line #131: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: r.JS('true'), })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: r.JS("true")}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #131")
}
{
// default.yaml line #135
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].eq(1), default=r.js('false')) */
suite.T().Log("About to run line #135: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: r.JS('false'), })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: r.JS("false")}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #135")
}
{
// default.yaml line #139
/* err("ReqlNonExistenceError", "No attribute `a` in object:", []) */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `a` in object:")
/* arr.filter(lambda x:x['a'].eq(1), default=r.error()) */
suite.T().Log("About to run line #139: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: r.Error(), })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: r.Error()}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #139")
}
{
// default.yaml line #144
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* r.expr(False).do(lambda d:arr.filter(lambda x:x['a'].eq(1), default=d)) */
suite.T().Log("About to run line #144: r.Expr(false).Do(func(d r.Term) interface{} { return arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: d, })})")
runAndAssert(suite.Suite, expected_, r.Expr(false).Do(func(d r.Term) interface{} {
return arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: d})
}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #144")
}
{
// default.yaml line #148
/* [{}, {'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": 1}}
/* r.expr(True).do(lambda d:arr.filter(lambda x:x['a'].eq(1), default=d)).order_by('a') */
suite.T().Log("About to run line #148: r.Expr(true).Do(func(d r.Term) interface{} { return arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: d, })}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, r.Expr(true).Do(func(d r.Term) interface{} {
return arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: d})
}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #148")
}
{
// default.yaml line #154
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].default(0).eq(1)) */
suite.T().Log("About to run line #154: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(0).Eq(1)})")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(0).Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #154")
}
{
// default.yaml line #158
/* ([{}, {'a':null}, {'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].default(1).eq(1)).order_by('a') */
suite.T().Log("About to run line #158: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(1).Eq(1)}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(1).Eq(1) }).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #158")
}
{
// default.yaml line #162
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:x['a'].default(r.error()).eq(1)) */
suite.T().Log("About to run line #162: arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(r.Error()).Eq(1)})")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(r.Error()).Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #162")
}
{
// default.yaml line #168
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* r.expr(0).do(lambda i:arr.filter(lambda x:x['a'].default(i).eq(1))) */
suite.T().Log("About to run line #168: r.Expr(0).Do(func(i r.Term) interface{} { return arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(i).Eq(1)})})")
runAndAssert(suite.Suite, expected_, r.Expr(0).Do(func(i r.Term) interface{} {
return arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(i).Eq(1) })
}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #168")
}
{
// default.yaml line #172
/* ([{},{'a':null},{'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* r.expr(1).do(lambda i:arr.filter(lambda x:x['a'].default(i).eq(1))).order_by('a') */
suite.T().Log("About to run line #172: r.Expr(1).Do(func(i r.Term) interface{} { return arr.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(i).Eq(1)})}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, r.Expr(1).Do(func(i r.Term) interface{} {
return arr.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(i).Eq(1) })
}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #172")
}
{
// default.yaml line #177
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2))) */
suite.T().Log("About to run line #177: arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))})")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #177")
}
{
// default.yaml line #181
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=False) */
suite.T().Log("About to run line #181: arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: false, })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #181")
}
{
// default.yaml line #185
/* ([{}, {'a':null}, {'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* arr.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=True).order_by('a') */
suite.T().Log("About to run line #185: arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: true, }).OrderBy('a')")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: true}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #185")
}
{
// default.yaml line #189
/* err("ReqlNonExistenceError", "No attribute `a` in object:", []) */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `a` in object:")
/* arr.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=r.error()) */
suite.T().Log("About to run line #189: arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: r.Error(), })")
runAndAssert(suite.Suite, expected_, arr.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: r.Error()}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #189")
}
{
// default.yaml line #193
/* partial({'tables_created':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"tables_created": 1})
/* r.table_create('default_test') */
suite.T().Log("About to run line #193: r.TableCreate('default_test')")
runAndAssert(suite.Suite, expected_, r.TableCreate("default_test"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #193")
}
{
// default.yaml line #196
/* ({'deleted':0,'replaced':0,'generated_keys':arrlen(3,uuid()),'unchanged':0,'errors':0,'skipped':0,'inserted':3}) */
var expected_ map[interface{}]interface{} = map[interface{}]interface{}{"deleted": 0, "replaced": 0, "generated_keys": arrlen(3, compare.IsUUID()), "unchanged": 0, "errors": 0, "skipped": 0, "inserted": 3}
/* r.table('default_test').insert(arr) */
suite.T().Log("About to run line #196: r.Table('default_test').Insert(arr)")
runAndAssert(suite.Suite, expected_, r.Table("default_test").Insert(arr), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #196")
}
// default.yaml line #199
// tbl = r.table('default_test').order_by('a').pluck('a')
suite.T().Log("Possibly executing: var tbl r.Term = r.Table('default_test').OrderBy('a').Pluck('a')")
tbl := r.Table("default_test").OrderBy("a").Pluck("a")
_ = tbl // Prevent any noused variable errors
{
// default.yaml line #202
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].eq(1)) */
suite.T().Log("About to run line #202: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)})")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #202")
}
{
// default.yaml line #206
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].eq(1), default=False) */
suite.T().Log("About to run line #206: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: false, })")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #206")
}
{
// default.yaml line #210
/* [{}, {'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].eq(1), default=True) */
suite.T().Log("About to run line #210: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: true, })")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: true}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #210")
}
{
// default.yaml line #215
/* err("ReqlNonExistenceError", "No attribute `a` in object:", []) */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `a` in object:")
/* tbl.filter(lambda x:x['a'].eq(1), default=r.error()) */
suite.T().Log("About to run line #215: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: r.Error(), })")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: r.Error()}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #215")
}
{
// default.yaml line #220
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* r.expr(False).do(lambda d:tbl.filter(lambda x:x['a'].eq(1), default=d)) */
suite.T().Log("About to run line #220: r.Expr(false).Do(func(d r.Term) interface{} { return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: d, })})")
runAndAssert(suite.Suite, expected_, r.Expr(false).Do(func(d r.Term) interface{} {
return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: d})
}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #220")
}
{
// default.yaml line #224
/* [{}, {'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": 1}}
/* r.expr(True).do(lambda d:tbl.filter(lambda x:x['a'].eq(1), default=d)).order_by('a') */
suite.T().Log("About to run line #224: r.Expr(true).Do(func(d r.Term) interface{} { return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Eq(1)}).OptArgs(r.FilterOpts{Default: d, })}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, r.Expr(true).Do(func(d r.Term) interface{} {
return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Eq(1) }).OptArgs(r.FilterOpts{Default: d})
}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #224")
}
{
// default.yaml line #230
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].default(0).eq(1)) */
suite.T().Log("About to run line #230: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(0).Eq(1)})")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(0).Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #230")
}
{
// default.yaml line #234
/* ([{}, {'a':null}, {'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].default(1).eq(1)).order_by('a') */
suite.T().Log("About to run line #234: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(1).Eq(1)}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(1).Eq(1) }).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #234")
}
{
// default.yaml line #238
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:x['a'].default(r.error()).eq(1)) */
suite.T().Log("About to run line #238: tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(r.Error()).Eq(1)})")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(r.Error()).Eq(1) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #238")
}
{
// default.yaml line #244
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* r.expr(0).do(lambda i:tbl.filter(lambda x:x['a'].default(i).eq(1))) */
suite.T().Log("About to run line #244: r.Expr(0).Do(func(i r.Term) interface{} { return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(i).Eq(1)})})")
runAndAssert(suite.Suite, expected_, r.Expr(0).Do(func(i r.Term) interface{} {
return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(i).Eq(1) })
}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #244")
}
{
// default.yaml line #248
/* ([{},{'a':null},{'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* r.expr(1).do(lambda i:tbl.filter(lambda x:x['a'].default(i).eq(1))).order_by('a') */
suite.T().Log("About to run line #248: r.Expr(1).Do(func(i r.Term) interface{} { return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex('a').Default(i).Eq(1)})}).OrderBy('a')")
runAndAssert(suite.Suite, expected_, r.Expr(1).Do(func(i r.Term) interface{} {
return tbl.Filter(func(x r.Term) interface{} { return x.AtIndex("a").Default(i).Eq(1) })
}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #248")
}
{
// default.yaml line #253
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2))) */
suite.T().Log("About to run line #253: tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))})")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #253")
}
{
// default.yaml line #257
/* [{'a':1}] */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=False) */
suite.T().Log("About to run line #257: tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: false, })")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: false}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #257")
}
{
// default.yaml line #261
/* ([{}, {'a':null}, {'a':1}]) */
var expected_ []interface{} = []interface{}{map[interface{}]interface{}{}, map[interface{}]interface{}{"a": nil}, map[interface{}]interface{}{"a": 1}}
/* tbl.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=True).order_by('a') */
suite.T().Log("About to run line #261: tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: true, }).OrderBy('a')")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: true}).OrderBy("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #261")
}
{
// default.yaml line #265
/* err("ReqlNonExistenceError", "No attribute `a` in object:", []) */
var expected_ Err = err("ReqlNonExistenceError", "No attribute `a` in object:")
/* tbl.filter(lambda x:r.or_(x['a'].eq(1), x['a']['b'].eq(2)), default=r.error()) */
suite.T().Log("About to run line #265: tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex('a').Eq(1), x.AtIndex('a').AtIndex('b').Eq(2))}).OptArgs(r.FilterOpts{Default: r.Error(), })")
runAndAssert(suite.Suite, expected_, tbl.Filter(func(x r.Term) interface{} { return r.Or(x.AtIndex("a").Eq(1), x.AtIndex("a").AtIndex("b").Eq(2)) }).OptArgs(r.FilterOpts{Default: r.Error()}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #265")
}
{
// default.yaml line #269
/* partial({'tables_dropped':1}) */
var expected_ compare.Expected = compare.PartialMatch(map[interface{}]interface{}{"tables_dropped": 1})
/* r.table_drop('default_test') */
suite.T().Log("About to run line #269: r.TableDrop('default_test')")
runAndAssert(suite.Suite, expected_, r.TableDrop("default_test"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #269")
}
}
func (suite *TimesTimezonesSuite) TestCases() {
suite.T().Log("Running TimesTimezonesSuite: Test basic timezone manipulation")
// times/timezones.yaml line #3
// t1 = r.time(2013, r.july, 29, 23, 30, 0, "+00:00")
suite.T().Log("Possibly executing: var t1 r.Term = r.Time(2013, r.July, 29, 23, 30, 0, '+00:00')")
t1 := r.Time(2013, r.July, 29, 23, 30, 0, "+00:00")
_ = t1 // Prevent any noused variable errors
// times/timezones.yaml line #5
// tutc1 = t1.in_timezone("Z")
suite.T().Log("Possibly executing: var tutc1 r.Term = t1.InTimezone('Z')")
tutc1 := t1.InTimezone("Z")
_ = tutc1 // Prevent any noused variable errors
// times/timezones.yaml line #6
// tutc2 = t1.in_timezone("+00:00")
suite.T().Log("Possibly executing: var tutc2 r.Term = t1.InTimezone('+00:00')")
tutc2 := t1.InTimezone("+00:00")
_ = tutc2 // Prevent any noused variable errors
// times/timezones.yaml line #7
// tutc3 = t1.in_timezone("+00")
suite.T().Log("Possibly executing: var tutc3 r.Term = t1.InTimezone('+00')")
tutc3 := t1.InTimezone("+00")
_ = tutc3 // Prevent any noused variable errors
// times/timezones.yaml line #8
// tutcs = r.expr([tutc1, tutc2, tutc3])
suite.T().Log("Possibly executing: var tutcs r.Term = r.Expr([]interface{}{tutc1, tutc2, tutc3})")
tutcs := r.Expr([]interface{}{tutc1, tutc2, tutc3})
_ = tutcs // Prevent any noused variable errors
// times/timezones.yaml line #10
// tm1 = t1.in_timezone("-00:59")
suite.T().Log("Possibly executing: var tm1 r.Term = t1.InTimezone('-00:59')")
tm1 := t1.InTimezone("-00:59")
_ = tm1 // Prevent any noused variable errors
// times/timezones.yaml line #11
// tm2 = t1.in_timezone("-01:00")
suite.T().Log("Possibly executing: var tm2 r.Term = t1.InTimezone('-01:00')")
tm2 := t1.InTimezone("-01:00")
_ = tm2 // Prevent any noused variable errors
// times/timezones.yaml line #12
// tm3 = t1.in_timezone("-01:01")
suite.T().Log("Possibly executing: var tm3 r.Term = t1.InTimezone('-01:01')")
tm3 := t1.InTimezone("-01:01")
_ = tm3 // Prevent any noused variable errors
// times/timezones.yaml line #13
// tms = r.expr([tm1, tm2, tm3])
suite.T().Log("Possibly executing: var tms r.Term = r.Expr([]interface{}{tm1, tm2, tm3})")
tms := r.Expr([]interface{}{tm1, tm2, tm3})
_ = tms // Prevent any noused variable errors
// times/timezones.yaml line #15
// tp1 = t1.in_timezone("+00:59")
suite.T().Log("Possibly executing: var tp1 r.Term = t1.InTimezone('+00:59')")
tp1 := t1.InTimezone("+00:59")
_ = tp1 // Prevent any noused variable errors
// times/timezones.yaml line #16
// tp2 = t1.in_timezone("+01:00")
suite.T().Log("Possibly executing: var tp2 r.Term = t1.InTimezone('+01:00')")
tp2 := t1.InTimezone("+01:00")
_ = tp2 // Prevent any noused variable errors
// times/timezones.yaml line #17
// tp3 = t1.in_timezone("+01:01")
suite.T().Log("Possibly executing: var tp3 r.Term = t1.InTimezone('+01:01')")
tp3 := t1.InTimezone("+01:01")
_ = tp3 // Prevent any noused variable errors
// times/timezones.yaml line #18
// tps = r.expr([tp1, tp2, tp3])
suite.T().Log("Possibly executing: var tps r.Term = r.Expr([]interface{}{tp1, tp2, tp3})")
tps := r.Expr([]interface{}{tp1, tp2, tp3})
_ = tps // Prevent any noused variable errors
// times/timezones.yaml line #20
// ts = tutcs.union(tms).union(tps).union([t1])
suite.T().Log("Possibly executing: var ts r.Term = tutcs.Union(tms).Union(tps).Union([]interface{}{t1})")
ts := tutcs.Union(tms).Union(tps).Union([]interface{}{t1})
_ = ts // Prevent any noused variable errors
{
// times/timezones.yaml line #23
/* ([["+00:00", 29], ["+00:00", 29], ["+00:00", 29]]) */
var expected_ []interface{} = []interface{}{[]interface{}{"+00:00", 29}, []interface{}{"+00:00", 29}, []interface{}{"+00:00", 29}}
/* tutcs.map(lambda x:[x.timezone(), x.day()]) */
suite.T().Log("About to run line #23: tutcs.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()}})")
runAndAssert(suite.Suite, expected_, tutcs.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #23")
}
{
// times/timezones.yaml line #27
/* ([["-00:59", 29], ["-01:00", 29], ["-01:01", 29]]) */
var expected_ []interface{} = []interface{}{[]interface{}{"-00:59", 29}, []interface{}{"-01:00", 29}, []interface{}{"-01:01", 29}}
/* tms.map(lambda x:[x.timezone(), x.day()]) */
suite.T().Log("About to run line #27: tms.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()}})")
runAndAssert(suite.Suite, expected_, tms.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #27")
}
{
// times/timezones.yaml line #31
/* ([["+00:59", 30], ["+01:00", 30], ["+01:01", 30]]) */
var expected_ []interface{} = []interface{}{[]interface{}{"+00:59", 30}, []interface{}{"+01:00", 30}, []interface{}{"+01:01", 30}}
/* tps.map(lambda x:[x.timezone(), x.day()]) */
suite.T().Log("About to run line #31: tps.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()}})")
runAndAssert(suite.Suite, expected_, tps.Map(func(x r.Term) interface{} { return []interface{}{x.Timezone(), x.Day()} }), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #31")
}
{
// times/timezones.yaml line #38
/* ([0]) */
var expected_ []interface{} = []interface{}{0}
/* ts.concat_map(lambda x:ts.map(lambda y:x - y)).distinct() */
suite.T().Log("About to run line #38: ts.ConcatMap(func(x r.Term) interface{} { return ts.Map(func(y r.Term) interface{} { return r.Sub(x, y)})}).Distinct()")
runAndAssert(suite.Suite, expected_, ts.ConcatMap(func(x r.Term) interface{} { return ts.Map(func(y r.Term) interface{} { return r.Sub(x, y) }) }).Distinct(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #38")
}
{
// times/timezones.yaml line #44
/* err('ReqlQueryLogicError', 'Timezone `` does not start with `-` or `+`.') */
var expected_ Err = err("ReqlQueryLogicError", "Timezone `` does not start with `-` or `+`.")
/* r.now().in_timezone("") */
suite.T().Log("About to run line #44: r.Now().InTimezone('')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone(""), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #44")
}
{
// times/timezones.yaml line #47
/* err('ReqlQueryLogicError', '`-00` is not a valid time offset.') */
var expected_ Err = err("ReqlQueryLogicError", "`-00` is not a valid time offset.")
/* r.now().in_timezone("-00") */
suite.T().Log("About to run line #47: r.Now().InTimezone('-00')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone("-00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #47")
}
{
// times/timezones.yaml line #50
/* err('ReqlQueryLogicError', '`-00:00` is not a valid time offset.') */
var expected_ Err = err("ReqlQueryLogicError", "`-00:00` is not a valid time offset.")
/* r.now().in_timezone("-00:00") */
suite.T().Log("About to run line #50: r.Now().InTimezone('-00:00')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone("-00:00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #50")
}
{
// times/timezones.yaml line #53
/* err('ReqlQueryLogicError', 'Timezone `UTC+00` does not start with `-` or `+`.') */
var expected_ Err = err("ReqlQueryLogicError", "Timezone `UTC+00` does not start with `-` or `+`.")
/* r.now().in_timezone("UTC+00") */
suite.T().Log("About to run line #53: r.Now().InTimezone('UTC+00')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone("UTC+00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #53")
}
{
// times/timezones.yaml line #56
/* err('ReqlQueryLogicError', 'Minutes out of range in `+00:60`.') */
var expected_ Err = err("ReqlQueryLogicError", "Minutes out of range in `+00:60`.")
/* r.now().in_timezone("+00:60") */
suite.T().Log("About to run line #56: r.Now().InTimezone('+00:60')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone("+00:60"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #56")
}
{
// times/timezones.yaml line #59
/* err('ReqlQueryLogicError', 'Hours out of range in `+25:00`.') */
var expected_ Err = err("ReqlQueryLogicError", "Hours out of range in `+25:00`.")
/* r.now().in_timezone("+25:00") */
suite.T().Log("About to run line #59: r.Now().InTimezone('+25:00')")
runAndAssert(suite.Suite, expected_, r.Now().InTimezone("+25:00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #59")
}
{
// times/timezones.yaml line #63
/* err('ReqlQueryLogicError', 'Timezone `` does not start with `-` or `+`.') */
var expected_ Err = err("ReqlQueryLogicError", "Timezone `` does not start with `-` or `+`.")
/* r.time(2013, 1, 1, "") */
suite.T().Log("About to run line #63: r.Time(2013, 1, 1, '')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, ""), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #63")
}
{
// times/timezones.yaml line #66
/* err('ReqlQueryLogicError', '`-00` is not a valid time offset.') */
var expected_ Err = err("ReqlQueryLogicError", "`-00` is not a valid time offset.")
/* r.time(2013, 1, 1, "-00") */
suite.T().Log("About to run line #66: r.Time(2013, 1, 1, '-00')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, "-00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #66")
}
{
// times/timezones.yaml line #69
/* err('ReqlQueryLogicError', '`-00:00` is not a valid time offset.') */
var expected_ Err = err("ReqlQueryLogicError", "`-00:00` is not a valid time offset.")
/* r.time(2013, 1, 1, "-00:00") */
suite.T().Log("About to run line #69: r.Time(2013, 1, 1, '-00:00')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, "-00:00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #69")
}
{
// times/timezones.yaml line #72
/* err('ReqlQueryLogicError', 'Timezone `UTC+00` does not start with `-` or `+`.') */
var expected_ Err = err("ReqlQueryLogicError", "Timezone `UTC+00` does not start with `-` or `+`.")
/* r.time(2013, 1, 1, "UTC+00") */
suite.T().Log("About to run line #72: r.Time(2013, 1, 1, 'UTC+00')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, "UTC+00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #72")
}
{
// times/timezones.yaml line #75
/* err('ReqlQueryLogicError', 'Minutes out of range in `+00:60`.') */
var expected_ Err = err("ReqlQueryLogicError", "Minutes out of range in `+00:60`.")
/* r.time(2013, 1, 1, "+00:60") */
suite.T().Log("About to run line #75: r.Time(2013, 1, 1, '+00:60')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, "+00:60"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #75")
}
{
// times/timezones.yaml line #78
/* err('ReqlQueryLogicError', 'Hours out of range in `+25:00`.') */
var expected_ Err = err("ReqlQueryLogicError", "Hours out of range in `+25:00`.")
/* r.time(2013, 1, 1, "+25:00") */
suite.T().Log("About to run line #78: r.Time(2013, 1, 1, '+25:00')")
runAndAssert(suite.Suite, expected_, r.Time(2013, 1, 1, "+25:00"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #78")
}
{
// times/timezones.yaml line #81
/* ("2015-07-08T00:00:00-08:00") */
var expected_ string = "2015-07-08T00:00:00-08:00"
/* r.epoch_time(1436428422.339).in_timezone('-08:00').date().to_iso8601() */
suite.T().Log("About to run line #81: r.EpochTime(1436428422.339).InTimezone('-08:00').Date().ToISO8601()")
runAndAssert(suite.Suite, expected_, r.EpochTime(1436428422.339).InTimezone("-08:00").Date().ToISO8601(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #81")
}
{
// times/timezones.yaml line #85
/* ("2015-07-09T00:00:00-07:00") */
var expected_ string = "2015-07-09T00:00:00-07:00"
/* r.epoch_time(1436428422.339).in_timezone('-07:00').date().to_iso8601() */
suite.T().Log("About to run line #85: r.EpochTime(1436428422.339).InTimezone('-07:00').Date().ToISO8601()")
runAndAssert(suite.Suite, expected_, r.EpochTime(1436428422.339).InTimezone("-07:00").Date().ToISO8601(), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #85")
}
}
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 *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")
}
}