func (suite *MathLogicComparisonSuite) TestCases() {
suite.T().Log("Running MathLogicComparisonSuite: Tests of comparison operators")
{
// math_logic/comparison.yaml line #10
/* true */
var expected_ bool = true
/* r.expr(1) < 2 */
suite.T().Log("About to run line #10: r.Expr(1).Lt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Lt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #10")
}
{
// math_logic/comparison.yaml line #11
/* true */
var expected_ bool = true
/* 1 < r.expr(2) */
suite.T().Log("About to run line #11: r.Lt(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Lt(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #11")
}
{
// math_logic/comparison.yaml line #12
/* true */
var expected_ bool = true
/* r.expr(1).lt(2) */
suite.T().Log("About to run line #12: r.Expr(1).Lt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Lt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #12")
}
{
// math_logic/comparison.yaml line #19
/* false */
var expected_ bool = false
/* r.expr(3) < 2 */
suite.T().Log("About to run line #19: r.Expr(3).Lt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Lt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #19")
}
{
// math_logic/comparison.yaml line #22
/* false */
var expected_ bool = false
/* r.expr(2) < 2 */
suite.T().Log("About to run line #22: r.Expr(2).Lt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Lt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #22")
}
{
// math_logic/comparison.yaml line #38
/* false */
var expected_ bool = false
/* r.expr(1) > 2 */
suite.T().Log("About to run line #38: r.Expr(1).Gt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Gt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #38")
}
{
// math_logic/comparison.yaml line #39
/* false */
var expected_ bool = false
/* 1 > r.expr(2) */
suite.T().Log("About to run line #39: r.Gt(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Gt(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #39")
}
{
// math_logic/comparison.yaml line #40
/* false */
var expected_ bool = false
/* r.expr(1).gt(2) */
suite.T().Log("About to run line #40: r.Expr(1).Gt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Gt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #40")
}
{
// math_logic/comparison.yaml line #45
/* true */
var expected_ bool = true
/* r.expr(3) > 2 */
suite.T().Log("About to run line #45: r.Expr(3).Gt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Gt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #45")
}
{
// math_logic/comparison.yaml line #49
/* false */
var expected_ bool = false
/* r.expr(2) > 2 */
suite.T().Log("About to run line #49: r.Expr(2).Gt(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Gt(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #49")
}
{
// math_logic/comparison.yaml line #63
/* false */
var expected_ bool = false
/* r.expr(1) == 2 */
suite.T().Log("About to run line #63: r.Expr(1).Eq(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Eq(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #63")
}
{
// math_logic/comparison.yaml line #64
/* false */
var expected_ bool = false
/* 1 == r.expr(2) */
suite.T().Log("About to run line #64: r.Eq(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Eq(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #64")
}
{
// math_logic/comparison.yaml line #65
/* false */
var expected_ bool = false
/* r.expr(1).eq(2) */
suite.T().Log("About to run line #65: r.Expr(1).Eq(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Eq(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #65")
}
{
// math_logic/comparison.yaml line #68
/* false */
var expected_ bool = false
/* r.expr(3) == 2 */
suite.T().Log("About to run line #68: r.Expr(3).Eq(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Eq(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #68")
}
{
// math_logic/comparison.yaml line #72
/* true */
var expected_ bool = true
/* r.expr(2) == 2 */
suite.T().Log("About to run line #72: r.Expr(2).Eq(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Eq(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #72")
}
{
// math_logic/comparison.yaml line #86
/* true */
var expected_ bool = true
/* r.expr(1) != 2 */
suite.T().Log("About to run line #86: r.Expr(1).Ne(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Ne(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #86")
}
{
// math_logic/comparison.yaml line #87
/* true */
var expected_ bool = true
/* 1 != r.expr(2) */
suite.T().Log("About to run line #87: r.Ne(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Ne(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #87")
}
{
// math_logic/comparison.yaml line #88
/* true */
var expected_ bool = true
/* r.expr(1).ne(2) */
suite.T().Log("About to run line #88: r.Expr(1).Ne(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Ne(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #88")
}
{
// math_logic/comparison.yaml line #91
/* true */
var expected_ bool = true
/* r.expr(3) != 2 */
suite.T().Log("About to run line #91: r.Expr(3).Ne(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Ne(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #91")
}
{
// math_logic/comparison.yaml line #95
/* false */
var expected_ bool = false
/* r.expr(2) != 2 */
suite.T().Log("About to run line #95: r.Expr(2).Ne(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Ne(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #95")
}
{
// math_logic/comparison.yaml line #109
/* true */
var expected_ bool = true
/* r.expr(1) <= 2 */
suite.T().Log("About to run line #109: r.Expr(1).Le(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Le(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #109")
}
{
// math_logic/comparison.yaml line #110
/* true */
var expected_ bool = true
/* 1 <= r.expr(2) */
suite.T().Log("About to run line #110: r.Le(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Le(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #110")
}
{
// math_logic/comparison.yaml line #111
/* true */
var expected_ bool = true
/* r.expr(1).le(2) */
suite.T().Log("About to run line #111: r.Expr(1).Le(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Le(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #111")
}
{
// math_logic/comparison.yaml line #116
/* false */
var expected_ bool = false
/* r.expr(3) <= 2 */
suite.T().Log("About to run line #116: r.Expr(3).Le(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Le(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #116")
}
{
// math_logic/comparison.yaml line #120
/* true */
var expected_ bool = true
/* r.expr(2) <= 2 */
suite.T().Log("About to run line #120: r.Expr(2).Le(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Le(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #120")
}
{
// math_logic/comparison.yaml line #134
/* false */
var expected_ bool = false
/* r.expr(1) >= 2 */
suite.T().Log("About to run line #134: r.Expr(1).Ge(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Ge(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #134")
}
{
// math_logic/comparison.yaml line #135
/* false */
var expected_ bool = false
/* 1 >= r.expr(2) */
suite.T().Log("About to run line #135: r.Ge(1, r.Expr(2))")
runAndAssert(suite.Suite, expected_, r.Ge(1, r.Expr(2)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #135")
}
{
// math_logic/comparison.yaml line #136
/* false */
var expected_ bool = false
/* r.expr(1).ge(2) */
suite.T().Log("About to run line #136: r.Expr(1).Ge(2)")
runAndAssert(suite.Suite, expected_, r.Expr(1).Ge(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #136")
}
{
// math_logic/comparison.yaml line #141
/* true */
var expected_ bool = true
/* r.expr(3) >= 2 */
suite.T().Log("About to run line #141: r.Expr(3).Ge(2)")
runAndAssert(suite.Suite, expected_, r.Expr(3).Ge(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #141")
}
{
// math_logic/comparison.yaml line #145
/* true */
var expected_ bool = true
/* r.expr(2) >= 2 */
suite.T().Log("About to run line #145: r.Expr(2).Ge(2)")
runAndAssert(suite.Suite, expected_, r.Expr(2).Ge(2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #145")
}
{
// math_logic/comparison.yaml line #158
/* true */
var expected_ bool = true
/* r.expr(null) == null */
suite.T().Log("About to run line #158: r.Expr(nil).Eq(nil)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Eq(nil), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #158")
}
{
// math_logic/comparison.yaml line #159
/* true */
var expected_ bool = true
/* null == r.expr(null) */
suite.T().Log("About to run line #159: r.Eq(nil, r.Expr(nil))")
runAndAssert(suite.Suite, expected_, r.Eq(nil, r.Expr(nil)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #159")
}
{
// math_logic/comparison.yaml line #164
/* false */
var expected_ bool = false
/* r.expr(null) < null */
suite.T().Log("About to run line #164: r.Expr(nil).Lt(nil)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(nil), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #164")
}
{
// math_logic/comparison.yaml line #165
/* false */
var expected_ bool = false
/* null < r.expr(null) */
suite.T().Log("About to run line #165: r.Lt(nil, r.Expr(nil))")
runAndAssert(suite.Suite, expected_, r.Lt(nil, r.Expr(nil)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #165")
}
{
// math_logic/comparison.yaml line #166
/* false */
var expected_ bool = false
/* r.expr(null).lt(null) */
suite.T().Log("About to run line #166: r.Expr(nil).Lt(nil)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(nil), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #166")
}
{
// math_logic/comparison.yaml line #172
/* false */
var expected_ bool = false
/* r.expr(null) > null */
suite.T().Log("About to run line #172: r.Expr(nil).Gt(nil)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt(nil), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #172")
}
{
// math_logic/comparison.yaml line #173
/* false */
var expected_ bool = false
/* null > r.expr(null) */
suite.T().Log("About to run line #173: r.Gt(nil, r.Expr(nil))")
runAndAssert(suite.Suite, expected_, r.Gt(nil, r.Expr(nil)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #173")
}
{
// math_logic/comparison.yaml line #174
/* false */
var expected_ bool = false
/* r.expr(null).gt(null) */
suite.T().Log("About to run line #174: r.Expr(nil).Gt(nil)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt(nil), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #174")
}
{
// math_logic/comparison.yaml line #180
/* true */
var expected_ bool = true
/* r.expr('a') == 'a' */
suite.T().Log("About to run line #180: r.Expr('a').Eq('a')")
runAndAssert(suite.Suite, expected_, r.Expr("a").Eq("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #180")
}
{
// math_logic/comparison.yaml line #184
/* false */
var expected_ bool = false
/* r.expr('a') == 'aa' */
suite.T().Log("About to run line #184: r.Expr('a').Eq('aa')")
runAndAssert(suite.Suite, expected_, r.Expr("a").Eq("aa"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #184")
}
{
// math_logic/comparison.yaml line #188
/* true */
var expected_ bool = true
/* r.expr('a') < 'aa' */
suite.T().Log("About to run line #188: r.Expr('a').Lt('aa')")
runAndAssert(suite.Suite, expected_, r.Expr("a").Lt("aa"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #188")
}
{
// math_logic/comparison.yaml line #192
/* true */
var expected_ bool = true
/* r.expr('a') < 'bb' */
suite.T().Log("About to run line #192: r.Expr('a').Lt('bb')")
runAndAssert(suite.Suite, expected_, r.Expr("a").Lt("bb"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #192")
}
{
// math_logic/comparison.yaml line #196
/* true */
var expected_ bool = true
/* r.expr('bb') > 'a' */
suite.T().Log("About to run line #196: r.Expr('bb').Gt('a')")
runAndAssert(suite.Suite, expected_, r.Expr("bb").Gt("a"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #196")
}
{
// math_logic/comparison.yaml line #200
/* true */
var expected_ bool = true
/* r.expr('abcdef') < 'abcdeg' */
suite.T().Log("About to run line #200: r.Expr('abcdef').Lt('abcdeg')")
runAndAssert(suite.Suite, expected_, r.Expr("abcdef").Lt("abcdeg"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #200")
}
{
// math_logic/comparison.yaml line #204
/* false */
var expected_ bool = false
/* r.expr('abcdefg') > 'abcdeg' */
suite.T().Log("About to run line #204: r.Expr('abcdefg').Gt('abcdeg')")
runAndAssert(suite.Suite, expected_, r.Expr("abcdefg").Gt("abcdeg"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #204")
}
{
// math_logic/comparison.yaml line #208
/* true */
var expected_ bool = true
/* r.expr('A quick brown fox') > 'A quick brawn fox' */
suite.T().Log("About to run line #208: r.Expr('A quick brown fox').Gt('A quick brawn fox')")
runAndAssert(suite.Suite, expected_, r.Expr("A quick brown fox").Gt("A quick brawn fox"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #208")
}
{
// math_logic/comparison.yaml line #216
/* true */
var expected_ bool = true
/* r.expr([1]) < [2] */
suite.T().Log("About to run line #216: r.Expr([]interface{}{1}).Lt([]interface{}{2})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Lt([]interface{}{2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #216")
}
{
// math_logic/comparison.yaml line #221
/* false */
var expected_ bool = false
/* r.expr([1]) > [2] */
suite.T().Log("About to run line #221: r.Expr([]interface{}{1}).Gt([]interface{}{2})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1}).Gt([]interface{}{2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #221")
}
{
// math_logic/comparison.yaml line #226
/* true */
var expected_ bool = true
/* r.expr([1, 0]) < [2] */
suite.T().Log("About to run line #226: r.Expr([]interface{}{1, 0}).Lt([]interface{}{2})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Lt([]interface{}{2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #226")
}
{
// math_logic/comparison.yaml line #231
/* false */
var expected_ bool = false
/* r.expr([1, 0]) < [1] */
suite.T().Log("About to run line #231: r.Expr([]interface{}{1, 0}).Lt([]interface{}{1})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Lt([]interface{}{1}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #231")
}
{
// math_logic/comparison.yaml line #236
/* true */
var expected_ bool = true
/* r.expr([1, 0]) > [0] */
suite.T().Log("About to run line #236: r.Expr([]interface{}{1, 0}).Gt([]interface{}{0})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0}).Gt([]interface{}{0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #236")
}
{
// math_logic/comparison.yaml line #241
/* true */
var expected_ bool = true
/* r.expr([1, 'a']) < [1, 'b'] */
suite.T().Log("About to run line #241: r.Expr([]interface{}{1, 'a'}).Lt([]interface{}{1, 'b'})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, "a"}).Lt([]interface{}{1, "b"}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #241")
}
{
// math_logic/comparison.yaml line #246
/* true */
var expected_ bool = true
/* r.expr([0, 'z']) < [1, 'b'] */
suite.T().Log("About to run line #246: r.Expr([]interface{}{0, 'z'}).Lt([]interface{}{1, 'b'})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{0, "z"}).Lt([]interface{}{1, "b"}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #246")
}
{
// math_logic/comparison.yaml line #251
/* false */
var expected_ bool = false
/* r.expr([1, 1, 1]) < [1, 0, 2] */
suite.T().Log("About to run line #251: r.Expr([]interface{}{1, 1, 1}).Lt([]interface{}{1, 0, 2})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 1, 1}).Lt([]interface{}{1, 0, 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #251")
}
{
// math_logic/comparison.yaml line #256
/* true */
var expected_ bool = true
/* r.expr([1, 0, 2]) < [1, 1, 1] */
suite.T().Log("About to run line #256: r.Expr([]interface{}{1, 0, 2}).Lt([]interface{}{1, 1, 1})")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 0, 2}).Lt([]interface{}{1, 1, 1}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #256")
}
{
// math_logic/comparison.yaml line #263
/* true */
var expected_ bool = true
/* r.expr({'a':0}) == {'a':0} */
suite.T().Log("About to run line #263: r.Expr(map[interface{}]interface{}{'a': 0, }).Eq(map[interface{}]interface{}{'a': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0}).Eq(map[interface{}]interface{}{"a": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #263")
}
{
// math_logic/comparison.yaml line #267
/* true */
var expected_ bool = true
/* r.expr({'a':0, 'b':1}) == {'b':1, 'a':0} */
suite.T().Log("About to run line #267: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1}).Eq(map[interface{}]interface{}{"b": 1, "a": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #267")
}
{
// math_logic/comparison.yaml line #271
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'b':1, 'c':2}) == {'b':1, 'a':0} */
suite.T().Log("About to run line #271: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Eq(map[interface{}]interface{}{"b": 1, "a": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #271")
}
{
// math_logic/comparison.yaml line #275
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'b':1}) == {'b':1, 'a':0, 'c':2} */
suite.T().Log("About to run line #275: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1}).Eq(map[interface{}]interface{}{"b": 1, "a": 0, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #275")
}
{
// math_logic/comparison.yaml line #279
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'b':1, 'd':2}) == {'b':1, 'a':0, 'c':2} */
suite.T().Log("About to run line #279: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'd': 2, }).Eq(map[interface{}]interface{}{'b': 1, 'a': 0, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "d": 2}).Eq(map[interface{}]interface{}{"b": 1, "a": 0, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #279")
}
{
// math_logic/comparison.yaml line #283
/* true */
var expected_ bool = true
/* r.expr({'a':0}) < {'b':0} */
suite.T().Log("About to run line #283: r.Expr(map[interface{}]interface{}{'a': 0, }).Lt(map[interface{}]interface{}{'b': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #283")
}
{
// math_logic/comparison.yaml line #287
/* true */
var expected_ bool = true
/* r.expr({'a':1}) < {'b':0} */
suite.T().Log("About to run line #287: r.Expr(map[interface{}]interface{}{'a': 1, }).Lt(map[interface{}]interface{}{'b': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 1}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #287")
}
{
// math_logic/comparison.yaml line #291
/* false */
var expected_ bool = false
/* r.expr({'b':1}) < {'b':0} */
suite.T().Log("About to run line #291: r.Expr(map[interface{}]interface{}{'b': 1, }).Lt(map[interface{}]interface{}{'b': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"b": 1}).Lt(map[interface{}]interface{}{"b": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #291")
}
{
// math_logic/comparison.yaml line #295
/* false */
var expected_ bool = false
/* r.expr({'b':1}) < {'a':0} */
suite.T().Log("About to run line #295: r.Expr(map[interface{}]interface{}{'b': 1, }).Lt(map[interface{}]interface{}{'a': 0, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"b": 1}).Lt(map[interface{}]interface{}{"a": 0}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #295")
}
{
// math_logic/comparison.yaml line #299
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'b':1, 'c':2}) < {'a':0, 'b':1, 'c':2} */
suite.T().Log("About to run line #299: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #299")
}
{
// math_logic/comparison.yaml line #303
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'b':1, 'c':2, 'd':3}) < {'a':0, 'b':1, 'c':2} */
suite.T().Log("About to run line #303: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, 'd': 3, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2, "d": 3}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #303")
}
{
// math_logic/comparison.yaml line #307
/* true */
var expected_ bool = true
/* r.expr({'a':0, 'b':1, 'c':2}) < {'a':0, 'b':1, 'c':2, 'd':3} */
suite.T().Log("About to run line #307: r.Expr(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, 'd': 3, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2, "d": 3}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #307")
}
{
// math_logic/comparison.yaml line #311
/* false */
var expected_ bool = false
/* r.expr({'a':0, 'c':2}) < {'a':0, 'b':1, 'c':2} */
suite.T().Log("About to run line #311: r.Expr(map[interface{}]interface{}{'a': 0, 'c': 2, }).Lt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "c": 2}).Lt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #311")
}
{
// math_logic/comparison.yaml line #315
/* true */
var expected_ bool = true
/* r.expr({'a':0, 'c':2}) > {'a':0, 'b':1, 'c':2} */
suite.T().Log("About to run line #315: r.Expr(map[interface{}]interface{}{'a': 0, 'c': 2, }).Gt(map[interface{}]interface{}{'a': 0, 'b': 1, 'c': 2, })")
runAndAssert(suite.Suite, expected_, r.Expr(map[interface{}]interface{}{"a": 0, "c": 2}).Gt(map[interface{}]interface{}{"a": 0, "b": 1, "c": 2}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #315")
}
// math_logic/comparison.yaml line #331
// everything = r.expr([[],r.now(),r.binary(b"\x00"),false,null,-5,{},"a",r.maxval])
suite.T().Log("Possibly executing: var everything r.Term = r.Expr([]interface{}{[]interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, 'a', r.MaxVal})")
everything := r.Expr([]interface{}{[]interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, "a", r.MaxVal})
_ = everything // Prevent any noused variable errors
{
// math_logic/comparison.yaml line #336
/* true */
var expected_ bool = true
/* r.and_(r.args(everything.map(r.lt(r.minval, r.row)))) */
suite.T().Log("About to run line #336: r.And(r.Args(everything.Map(r.Lt(r.MinVal, r.Row))))")
runAndAssert(suite.Suite, expected_, r.And(r.Args(everything.Map(r.Lt(r.MinVal, r.Row)))), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #336")
}
{
// math_logic/comparison.yaml line #341
/* false */
var expected_ bool = false
/* r.or_(r.args(everything.map(r.gt(r.minval, r.row)))) */
suite.T().Log("About to run line #341: r.Or(r.Args(everything.Map(r.Gt(r.MinVal, r.Row))))")
runAndAssert(suite.Suite, expected_, r.Or(r.Args(everything.Map(r.Gt(r.MinVal, r.Row)))), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #341")
}
{
// math_logic/comparison.yaml line #345
/* true */
var expected_ bool = true
/* r.eq(r.minval, r.minval) */
suite.T().Log("About to run line #345: r.Eq(r.MinVal, r.MinVal)")
runAndAssert(suite.Suite, expected_, r.Eq(r.MinVal, r.MinVal), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #345")
}
{
// math_logic/comparison.yaml line #348
/* true */
var expected_ bool = true
/* r.expr([]) < True */
suite.T().Log("About to run line #348: r.Expr([]interface{}{}).Lt(true)")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Lt(true), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #348")
}
{
// math_logic/comparison.yaml line #353
/* true */
var expected_ bool = true
/* r.expr([1,2]) < False */
suite.T().Log("About to run line #353: r.Expr([]interface{}{1, 2}).Lt(false)")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 2}).Lt(false), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #353")
}
{
// math_logic/comparison.yaml line #358
/* false */
var expected_ bool = false
/* r.expr(False) < [] */
suite.T().Log("About to run line #358: r.Expr(false).Lt([]interface{}{})")
runAndAssert(suite.Suite, expected_, r.Expr(false).Lt([]interface{}{}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #358")
}
{
// math_logic/comparison.yaml line #363
/* true */
var expected_ bool = true
/* r.expr([]) < r.binary(b"\xAE") */
suite.T().Log("About to run line #363: r.Expr([]interface{}{}).Lt(r.Binary([]byte{174}))")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{}).Lt(r.Binary([]byte{174})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #363")
}
{
// math_logic/comparison.yaml line #368
/* true */
var expected_ bool = true
/* r.expr([1,2]) < r.binary(b"\xAE") */
suite.T().Log("About to run line #368: r.Expr([]interface{}{1, 2}).Lt(r.Binary([]byte{174}))")
runAndAssert(suite.Suite, expected_, r.Expr([]interface{}{1, 2}).Lt(r.Binary([]byte{174})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #368")
}
{
// math_logic/comparison.yaml line #373
/* true */
var expected_ bool = true
/* True < r.expr(null) */
suite.T().Log("About to run line #373: r.Lt(true, r.Expr(nil))")
runAndAssert(suite.Suite, expected_, r.Lt(true, r.Expr(nil)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #373")
}
{
// math_logic/comparison.yaml line #378
/* true */
var expected_ bool = true
/* r.expr(null) > [] */
suite.T().Log("About to run line #378: r.Expr(nil).Gt([]interface{}{})")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Gt([]interface{}{}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #378")
}
{
// math_logic/comparison.yaml line #383
/* true */
var expected_ bool = true
/* r.expr(null) < 12 */
suite.T().Log("About to run line #383: r.Expr(nil).Lt(12)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(12), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #383")
}
{
// math_logic/comparison.yaml line #388
/* true */
var expected_ bool = true
/* r.expr(null) < -2 */
suite.T().Log("About to run line #388: r.Expr(nil).Lt(-2)")
runAndAssert(suite.Suite, expected_, r.Expr(nil).Lt(-2), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #388")
}
{
// math_logic/comparison.yaml line #393
/* true */
var expected_ bool = true
/* r.expr(-12) < {} */
suite.T().Log("About to run line #393: r.Expr(-12).Lt(map[interface{}]interface{}{})")
runAndAssert(suite.Suite, expected_, r.Expr(-12).Lt(map[interface{}]interface{}{}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #393")
}
{
// math_logic/comparison.yaml line #398
/* true */
var expected_ bool = true
/* r.expr(100) < {'a':-12} */
suite.T().Log("About to run line #398: r.Expr(100).Lt(map[interface{}]interface{}{'a': -12, })")
runAndAssert(suite.Suite, expected_, r.Expr(100).Lt(map[interface{}]interface{}{"a": -12}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #398")
}
{
// math_logic/comparison.yaml line #403
/* false */
var expected_ bool = false
/* r.expr(r.binary(b"\xAE")) < 12 */
suite.T().Log("About to run line #403: r.Expr(r.Binary([]byte{174})).Lt(12)")
runAndAssert(suite.Suite, expected_, r.Expr(r.Binary([]byte{174})).Lt(12), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #403")
}
{
// math_logic/comparison.yaml line #408
/* true */
var expected_ bool = true
/* r.binary(b"0xAE") < 'abc' */
suite.T().Log("About to run line #408: r.Binary([]byte{48,120,65,69}).Lt('abc')")
runAndAssert(suite.Suite, expected_, r.Binary([]byte{48, 120, 65, 69}).Lt("abc"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #408")
}
{
// math_logic/comparison.yaml line #413
/* false */
var expected_ bool = false
/* r.binary(b"0xAE") > r.now() */
suite.T().Log("About to run line #413: r.Binary([]byte{48,120,65,69}).Gt(r.Now())")
runAndAssert(suite.Suite, expected_, r.Binary([]byte{48, 120, 65, 69}).Gt(r.Now()), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #413")
}
{
// math_logic/comparison.yaml line #418
/* true */
var expected_ bool = true
/* r.now() > 12 */
suite.T().Log("About to run line #418: r.Now().Gt(12)")
runAndAssert(suite.Suite, expected_, r.Now().Gt(12), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #418")
}
{
// math_logic/comparison.yaml line #422
/* false */
var expected_ bool = false
/* r.now() > 'abc' */
suite.T().Log("About to run line #422: r.Now().Gt('abc')")
runAndAssert(suite.Suite, expected_, r.Now().Gt("abc"), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #422")
}
{
// math_logic/comparison.yaml line #426
/* true */
var expected_ bool = true
/* r.expr("abc") > {'a':-12} */
suite.T().Log("About to run line #426: r.Expr('abc').Gt(map[interface{}]interface{}{'a': -12, })")
runAndAssert(suite.Suite, expected_, r.Expr("abc").Gt(map[interface{}]interface{}{"a": -12}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #426")
}
{
// math_logic/comparison.yaml line #431
/* true */
var expected_ bool = true
/* r.expr("abc") > {'abc':'abc'} */
suite.T().Log("About to run line #431: r.Expr('abc').Gt(map[interface{}]interface{}{'abc': 'abc', })")
runAndAssert(suite.Suite, expected_, r.Expr("abc").Gt(map[interface{}]interface{}{"abc": "abc"}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #431")
}
{
// math_logic/comparison.yaml line #436
/* true */
var expected_ bool = true
/* r.expr('zzz') > 128 */
suite.T().Log("About to run line #436: r.Expr('zzz').Gt(128)")
runAndAssert(suite.Suite, expected_, r.Expr("zzz").Gt(128), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #436")
}
{
// math_logic/comparison.yaml line #441
/* true */
var expected_ bool = true
/* r.expr('zzz') > {} */
suite.T().Log("About to run line #441: r.Expr('zzz').Gt(map[interface{}]interface{}{})")
runAndAssert(suite.Suite, expected_, r.Expr("zzz").Gt(map[interface{}]interface{}{}), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #441")
}
{
// math_logic/comparison.yaml line #446
/* true */
var expected_ bool = true
/* 'zzz' > r.expr(-152) */
suite.T().Log("About to run line #446: r.Gt('zzz', r.Expr(-152))")
runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr(-152)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #446")
}
{
// math_logic/comparison.yaml line #451
/* true */
var expected_ bool = true
/* 'zzz' > r.expr(null) */
suite.T().Log("About to run line #451: r.Gt('zzz', r.Expr(nil))")
runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr(nil)), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #451")
}
{
// math_logic/comparison.yaml line #456
/* true */
var expected_ bool = true
/* 'zzz' > r.expr([]) */
suite.T().Log("About to run line #456: r.Gt('zzz', r.Expr([]interface{}{}))")
runAndAssert(suite.Suite, expected_, r.Gt("zzz", r.Expr([]interface{}{})), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #456")
}
// math_logic/comparison.yaml line #463
// everything2 = r.expr([r.minval,[],r.now(),r.binary(b"\x00"),false,null,-5,{},"a"])
suite.T().Log("Possibly executing: var everything2 r.Term = r.Expr([]interface{}{r.MinVal, []interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, 'a'})")
everything2 := r.Expr([]interface{}{r.MinVal, []interface{}{}, r.Now(), r.Binary([]byte{0}), false, nil, -5, map[interface{}]interface{}{}, "a"})
_ = everything2 // Prevent any noused variable errors
{
// math_logic/comparison.yaml line #467
/* true */
var expected_ bool = true
/* r.and_(r.args(everything2.map(r.gt(r.maxval, r.row)))) */
suite.T().Log("About to run line #467: r.And(r.Args(everything2.Map(r.Gt(r.MaxVal, r.Row))))")
runAndAssert(suite.Suite, expected_, r.And(r.Args(everything2.Map(r.Gt(r.MaxVal, r.Row)))), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #467")
}
{
// math_logic/comparison.yaml line #472
/* false */
var expected_ bool = false
/* r.or_(r.args(everything2.map(r.lt(r.maxval, r.row)))) */
suite.T().Log("About to run line #472: r.Or(r.Args(everything2.Map(r.Lt(r.MaxVal, r.Row))))")
runAndAssert(suite.Suite, expected_, r.Or(r.Args(everything2.Map(r.Lt(r.MaxVal, r.Row)))), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #472")
}
{
// math_logic/comparison.yaml line #476
/* true */
var expected_ bool = true
/* r.eq(r.maxval, r.maxval) */
suite.T().Log("About to run line #476: r.Eq(r.MaxVal, r.MaxVal)")
runAndAssert(suite.Suite, expected_, r.Eq(r.MaxVal, r.MaxVal), suite.session, r.RunOpts{
GeometryFormat: "raw",
GroupFormat: "map",
})
suite.T().Log("Finished running line #476")
}
}
func (suite *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 *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")
}
}