echo Testing select on lists...
eval x = {
           [a = 3; b = "I see London"],
           [a = 2; b = "I see France"],
           [a = 1; b = "I see Alain's funky pants"]
         }
same $x.a, {3, 2, 1}
same $x.b, {"I see London", "I see France", "I see Alain's funky pants"}
same $x.c, {undefined, undefined, undefined}
same {}.a, {}

/////////////////////////////////
echo Testing basic math...
eval x = (1 + 2)
same $x, 3
eval x = (3 - 1) 
same $x, 2
eval x = (2 * 3)
same $x, 6
eval x = (8 / 2)
same $x, 4

echo Testing extreme numbers...
same string(real("INF")), "real(\"INF\")"
same string(real("-INF")), "real(\"-INF\")"
same string(real("NaN")), "real(\"NaN\")"
diff real("NaN"), real("NaN")
same real("INF"), real("INF")
same real("-INF"), real("-INF")
diff real("INF"), real("-INF")
same 0.0, -(0.0)
same 0.0, real("-0.0")
same string(0.0), "0.0"
same string(-0.0), "-0.0"

/////////////////////////////////
echo Testing basic attributes in a ClassAd...
eval x = [
            a = 1;
            b = 2.0;
            c = "alain";
            d = true;
            atime = absTime("2004-01-01");
            rtime = relTime("2+25:14:16.123");
            l = {1, 1, 2, 3, 5};
            e = error;
            u = undefined;
         ]
same $x.a, 1
same $x.b, 2.0
same $x.c, "alain"
same $x.d, true
same $x.atime, absTime("2004-01-01");
same $x.rtime, relTime("2+25:14:16.123");
same $x.l, {1, 1, 2, 3, 5}
same $x.l[4], 5
same $x.e, error
same $x.u, undefined
same isinteger($x.a), true
same isinteger($x.b), false
same isreal($x.b), true
same isreal($x.c), false
same isstring($x.c), true
same isstring($x.d), false
same isboolean($x.d), true
same isboolean($x.c), false
same isabstime($x.atime), true
same isabstime($x.rtime), false
same isreltime($x.rtime), true
same isreltime($x.atime), false
same islist($x.l), true
same islist($x.a), false
same iserror($x.e), true
same iserror($x.u), false
same isundefined($x.u), true
same isundefined($x.e), false

// Note that testing XML relies on the ClassAd from
// the above testing.
// echo Testing XML...
// eval y = [ a = 2; b = "Lisp rocks"; ]
// writexml tmp.xml {$x, $y}
// readxml z tmp.xml
// same $x, $z[0]
// same $y, $z[1]

/////////////////////////////////


/////////////////////////////////
echo Testing subscripts
eval x = [
           a = 3;
           b = "alain";
           ab = 4;
         ]
same $x["a"], 3
same $x["b"], "alain"
same $x["c"], error
eval d = $x["c"]
same $x[strcat("a", "b")], 4
eval x = {"a", "b", "c"}
same $x[0], "a"
same $x[1], "b"
same $x[2], "c"
same $x[3], error

/////////////////////////////////
echo Testing multiple semicolons...
eval x = [
           ;;
           a = 3;;
           b = 4;;
         ]

/////////////////////////////////
echo Testing functions...
same int(3), 3
same int(3.9), 3
same int("3.9"), 3
same int(absTime("1970-01-01T:00:00:01Z")), 1
same int(reltime("01:00:01")), 3601
eval y = int(absTime("1970-01-01T:00:00:01Z"))
same $y, 1

same real(3), 3.0
same real(3.9), 3.9
same real("3.9"), 3.9
same real(absTime("1970-01-01T:00:00:01Z")), 1.0
same real(reltime("01:00:01")), 3601.0

same string("alain"), "alain"
same string(1), "1"

same floor(3.9), 3
same floor("3.9"), 3

same ceiling(3.9), 4
same ceiling("3.9"), 4

same round(3.1), 3
same round(3.9), 4

same strcat("", "roy"), "roy"
same strcat("alain", ""), "alain"
same strcat("alain", "roy"), "alainroy"
same strcat(14, " bottles of root beer"), "14 bottles of root beer"

same substr("abcde", 1), "bcde"
same substr("abcde", 4), "e"
same substr("abcde", 5), ""
same substr("abcde", 1, 2), "bc"
same substr("abcde", 4, 2), "e"

same strcmp("alain", "roy") < 0, true
same strcmp("roy", "alain") > 0, true
same strcmp("alain", "alain"), 0

same stricmp("alain", "ALAIN"), 0
same stricmp("alain", "roy") < 0, true

same tolower("ALAIN"), "alain")
same toupper("alain"), "ALAIN")
same tolower(true), "true")
same toupper(true), "TRUE")

same member(1, {1, 2, 3}), true
same member(4, {1, 2, 3}), false

same regexp("Alain.*Roy", "Alain Aslag Roy"), true
same regexp("alain.*roy", "Alain Aslag Roy"), false
same regexp("alain.*roy", "Alain Aslag Roy", "i"), true

//same regexpMember("b.*", {}), false
//same regexpMember("b.*", {"aa"}), false
//same regexpMember("b.*", {"aa", "bb"}), true
//same regexpMember("b.*", {"bb", "aa"}), true
//same regexpMember("b.*", {1, "bb"} ), error


eval t = absTime("1970-01-02T:03:04:05Z")
same splitTime($t).year, 1970
same splitTime($t).month, 1
same splitTime($t).day, 2
same splitTime($t).hours, 3
same splitTime($t).minutes, 4
same splitTime($t).seconds, 5
same splitTime($t).offset, 0


eval t = absTime("1970-01-02T:03:04:05-06:00")
eval tt = splitTime($t)
same splitTime($t).year, 1970
same splitTime($t).month, 1
same splitTime($t).day, 2
same splitTime($t).hours, 3
same splitTime($t).minutes, 4
same splitTime($t).seconds, 5
same splitTime($t).offset, -21600


eval t = relTime("1d2h3m4.5s")
eval tt = splitTime($t)
same splitTime($t).days, 1
same splitTime($t).hours, 2
same splitTime($t).minutes, 3
same splittime($t).seconds, 4.5
eval tt = splitTime($t)


eval t = absTime("1997-08-30T16:04:05-0500")
eval f = formatTime($t, "%m %d %Y")
same $f, "08 30 1997"
eval f = formatTime($t, "%H %M %S")
same $f, "16 04 05"
eval f = formatTime($t, "%A %a")
same $f, "Saturday Sat"
eval f = formatTime($t, "%B %b")
same $f, "August Aug"
eval f = formatTime(splitTime($t), "%H:%M:%S")
same $f, "16:04:05"
eval f = formatTime($t)
same $f, "Sat Aug 30 16:04:05 1997"

same size({}), 0
same size({1}), 1
same size({1, 2, 3, 4, 5}), 5
same size([]), 0
same size([a = 1;]), 1
same size([a = 1; b = 2;]), 2
same size(""), 0
same size("a"), 1
same size("ab"), 2
same size(3), error
same size(3.4), error

eval list0 = {}
eval list1 = {1}
eval list5 = {1, 2, 3, 4, 5}

same sum($list0), undefined
same avg($list0), undefined
same min($list0), undefined
same max($list0), undefined
// #### Do we really want these to be false and true?
same anycompare("<", $list0, 3), false
same allcompare("<", $list0, 3), true

same sum($list1), 1
same avg($list1), 1.0
same min($list1), 1
same max($list1), 1
same anycompare("<", $list1, 3), true
same allcompare("<", $list1, 3), true

same sum($list5), 15
same avg($list5), 3.0
same min($list5), 1
same max($list5), 5
same anycompare("<", $list5, 3), true
same allcompare("<", $list5, 3), false

same ifThenElse(1+1==2, 3, 4), 3
same ifThenElse(1+1==3,3,4), 4
same ifThenElse(ERROR,3,4), ERROR
same ifThenElse(UNDEFINED,3,4), UNDEFINED

same interval(1), "1"
same interval(60*2 + 1), "2:01"
same interval(3600*3 + 60*2 + 1), "3:02:01"
same interval(3600*24*4 + 3600*3 + 60*2 + 1), "4+03:02:01"

//same regexps("[abc]*([def]*)[ghi]*","aaaabbbbcccccdddeeefffggghhhiii","\\1"), "dddeeefff"
//same regexps("[abc]*([def]*)[ghi]*","abcdefghi","\\0"), "abcdefghi"
//same regexps("[abc]*([def]*)[ghi]*","abcdefghi","\\2"), error
//same regexps("[abc]*([def]*)[ghi]*","NO","\\0"), ""


echo Testing eval
same eval("1+1"), 2
same eval(1+1), 2
same eval("1+"), ERROR
eval x = [ A = 1; B = 2; C = eval("A+B"); ]
same $x.C, 3

echo Testing boolean expressions
echo Testing && operator
same false, false && false
same false, false && undefined
same false, false && true
same false, false && error

same false, undefined && false
same undefined, undefined && undefined
same undefined, undefined && true
same error, undefined && error

same false, true && false
same undefined, true && undefined
same true, true && true
same error, true && error

same error, error && false
same error, error && undefined
same error, error && true
same error, error && error


echo Testing || operator
same false, false || false
same undefined, false || undefined
same true, false || true
same error, false || error

same undefined, undefined || false
same undefined, undefined || undefined
same true, undefined || true
same error, undefined || error

same true, true || false
same true, true || undefined
same true, true || true
same true, true || error

same error, error || false
same error, error || undefined
same error, error || true
same error, error || error


echo Testing ! operator
same true, !false
same undefined, !undefined
same false, !true
same error, !error


echo Testing ? operator
same false, false ? true : false
same true, false ? false : true
same undefined, false ? true : undefined
same true, false ? undefined : true

same true, true ? true : false
same false, true ? false : true
same true, true ? true : undefined
same undefined, true ? undefined : true

echo Testing characters with negative ascii values
// # the following used to not even parse on some systems
same "–", "–"

echo Testing stringListsIntersect()
same true, stringListsIntersect("one,two","two,three")
same false, stringListsIntersect("one,two","three,four")
same false, stringListsIntersect("one,two","three,four",";")
same true, stringListsIntersect("one,two","one")
same true, stringListsIntersect("one, two","two, three")
same true, stringListsIntersect("one,two","two,three",",")
same true, stringListsIntersect("one;two","two;three",";")
same undefined, stringListsIntersect("one,two",undefined)
same undefined, stringListsIntersect(undefined,"one,two" )