int main() { try { poc(); TestSection("LispEvaluations"); TestSubsection("ConstantEvaluations"); { LReference intref(25); TESTC("int_evaluating", intref.Evaluate(), intref); LReference floatref(25.55); TESTC("float_evaluating", floatref.Evaluate(), floatref); LReference stringref("string"); TESTC("string_evaluating", stringref.Evaluate(), stringref); } poc(); TestSubsection("LSymbol"); { LSymbol A("A"); LReference nullref; TESTC("unassigned_symbol", A->GetDynamicValue(), nullref); LReference ref(2552); A->SetDynamicValue(ref); TESTC("dynamic_value", A->GetDynamicValue(), ref); TESTC("dynamic_value_eval", LReference(A).Evaluate(), ref); } poc(); TestSubsection("LExpressionContext"); { LSymbol SS("SS"); LReference ref25(25); SS->SetDynamicValue(ref25); TESTC("setq_without_context", LReference(SS).Evaluate(), ref25); LContextRef pcont(new LExpressionContext); LReference unbound; TESTB("no_lex_binding", pcont->GetBinding(SS.GetPtr())==0); LReference ref36(36); pcont->AddBinding(SS.GetPtr(), ref36); SReference *pref; pref = pcont->GetBinding(SS.GetPtr()); TESTC("lex_binding_playback", *pref, ref36); TESTC("dynamic_value_unaffected", LReference(SS).Evaluate(), ref25); LContextRef emptycontext(new LExpressionContext); LispContinuation cont; cont.SetContext(emptycontext); TESTC("dynamic_value_when_no_lex", LReference(SS).Evaluate(cont), ref25); cont.SetContext(pcont); TESTC("lexical_value", LReference(SS).Evaluate(cont), ref36); TEST("lexical_value_txt", LReference(SS).Evaluate(cont)-> TextRepresentation().c_str(), "36"); // Now create an inner lexical context LContextRef pcont2(new LExpressionContext(pcont)); // And evaluate within it cont.SetContext(pcont2); TESTC("lexical_value_in_inner_context", LReference(SS).Evaluate(cont), ref36); #if 0 // Now lets change the value of SS LReference ref49(49); SS->Setq(ref49, pcont2); // We've just changed the EXISTING binding TESTC("inner_setq_changes_same_binding", *pref, ref49); // Let's shadow that binding by creating a new one LReference ref64(64); pcont2->AddLexicalBinding(SS.GetPtr(), ref64); // Now we test that it is in effect, // then return to the outer context // and see THAT binding is still unchanged TESTC("shadow_lexical_binding", LReference(SS).Evaluate(pcont2), ref64); TESTC("shadowed_binding_untouched", LReference(SS).Evaluate(pcont), ref49); #endif } poc(); TestSubsection("Dynamic_binding"); { LSymbol SS("SS"); LSymbol DD("DD"); TESTB("symbol_is_lexical_by_default", !(SS->IsDynamic())); SS->SetDynamicBinding(); TESTB("switch_to_dynamic_binding", SS->IsDynamic()); SS->SetDynamicBinding(false); TESTB("switch_back_to_lexical", !(SS->IsDynamic())); // Lets make DD dynamic DD->SetDynamicBinding(); // Let's assign a dynamic value to both symbols LReference ref25(25); SS->SetDynamicValue(ref25); DD->SetDynamicValue(ref25); // Now let's make a lexical context LContextRef pcont(new LExpressionContext); // We try to bind both symbols lexically, // and for DD that must have no visible effect // (unless we restore lexical binding style for it) LReference ref36(36); pcont->AddBinding(SS.GetPtr(), ref36); pcont->AddBinding(DD.GetPtr(), ref36); LispContinuation cont; cont.SetContext(pcont); TESTC("lex_symbol_obeys_lex_binding", LReference(SS).Evaluate(cont), ref36); TESTC("dyn_symbol_ignores_lex_binding", LReference(DD).Evaluate(cont), ref25); #if 0 // Now we Setq the both symbols and see that SS'dynamic value // is still untouched while DD's changed LReference ref49(49); SS->Setq(ref49, pcont); DD->Setq(ref49, pcont); // They now both evaluate to ref49 within the context TESTC("lex_symbol_setq", LReference(SS).Evaluate(pcont), ref49); TESTC("dyn_symbol_setq", LReference(DD).Evaluate(pcont), ref49); // ... but for SS it is lexical value while for DD is dynamic TESTC("lex_symbol_lex", SS->GetDynamicValue(), ref25); TESTC("dyn_symbol_dyn", DD->GetDynamicValue(), ref49); // Lets now return to the top-level and check if everything's Ok LContextRef topcont(new LExpressionContext); TESTC("lex_symbol_value_survived", LReference(SS).Evaluate(topcont), ref25); TESTC("dyn_symbol_value_changed", LReference(DD).Evaluate(topcont), ref49); #endif } poc(); TestSubsection("Apply"); { SListConstructor L; LReference plus = new LFunctionPlus; LReference res = plus.Apply((L|1,2,3)); TESTTR("apply", res, "6"); } TestSubsection("Form_evaluation"); { SListConstructor L; LSymbol A("A"); LReference frm = (L|QUOTE, A); LReference res = frm.Evaluate(); LReference must_be = A; TEST("evaluate_quote", res->TextRepresentation().c_str(), must_be->TextRepresentation().c_str()); frm = (L|QUOTE,(L|1, 2, 3)); TEST("evaluate_quoted_list", frm.Evaluate()->TextRepresentation().c_str(), "(1 2 3)"); } TestSubsection("UserLispFunctions"); { LListConstructor L; LSymbol f("f"); f->SetFunction(square); LReference fref = (L| f, 15); TEST("user_function", fref.Evaluate().GetInt(), 225); LReference fref2 = (L| square, 25); try { TEST("user_function_by_value", fref2.Evaluate().GetInt(), 625); } catch(...) { TESTB("user_function_by_value", false); } } TestScore(); poc(); } catch(IntelibX &x) { printf("\nCaught IntelibX: %s\n", x.Description() ); if(x.Parameter().GetPtr()) { printf("%s\n", x.Parameter()->TextRepresentation().c_str()); } } catch(...) { printf("Something strange caught\n"); } poc(); return 0; }
int main() { poc(); f(list(1, 2, 3, 4, 5)); }
int main() { poc(); try { TestSection("SVector"); TestSubsection("Matrix"); { SMatrix<5> matrix; matrix[1][2][1][0][1] = 123; matrix[2][1][0][1][4] = 777; TEST("matrix_1", matrix[1][2][1][0][1].GetInt(), 123); TEST("matrix_2", matrix[2][1][0][1][4].GetInt(), 777); } TestSubsection("Matrix_has_you"); { SVector m; SVector m0; SVector m1; SVector m00; SVector m01; SVector m10; SVector m11; m10[1] = SReference(25); m0[0] = m00; m0[1] = m01; m1[0] = m10; m1[1] = m11; m[0] = m0; m[1] = m1; SMatrixRef<3> matr(m); TEST("matrix_has_you", matr[1][0][1].GetInt(), 25); } TestSubsection("resize"); { SVector v; v[7] = 5; TEST("resize_1", v->Size(), 8); v[12] = 5; TEST("resize_2", v->Size(), 13); v[13] = 5; TEST("resize_3", v->Size(), 14); } #if INTELIB_DEBUG_COUNTERS == 1 TestSubsection("leaks"); { int before = SExpression::object_counter; { SVector v; v[7] = 5; SVectorRef vr(v); SVectorRef vr2; vr2 = vr; SVectorRef vr3(vr2); for(int i=0; i<200; i++) vr3[vr3->Size()] = SReference(i); } TEST("no_leaks", SExpression::object_counter, before); } #endif TestSubsection("TextRepresentation"); { SVector v; for(int i=0; i<5; i++) v[i]=i; TEST("text_rep", v->TextRepresentation().c_str(), "#~(0 1 2 3 4)"); } TestSubsection("Range Copying"); { SVector v; for(int i=0; i<15; i++) v[i]=i; SVectorRange r(v,5,3); TEST("range_copy", r.Copy()->TextRepresentation().c_str(), "#~(5 6 7)"); TESTB("copy_keeps_positive_resizeability", r.Copy()->IsResizeable()); SVector vn(5); for(int i=0; i<5; i++) vn[i]=i*100; SVectorRange rn(vn,1,2); TESTB("copy_keeps_negative_resizeability", !rn.Copy()->IsResizeable()); TESTB("copy_positive_resizeability", rn.Copy(true)->IsResizeable()); TESTB("copy_negative_resizeability", !rn.Copy(false)->IsResizeable()); SVectorRange r200(v,5,200); TEST("range_size_limited", r200.Copy()->Size(), 10); } TestSubsection("Range Erasing"); { SVector v; for(int i=0; i<15; i++) v[i]=i; SVectorRange r(v,3,10); r.Erase(); TEST("range_erase", v->TextRepresentation().c_str(), "#~(0 1 2 13 14)"); TEST("range_erase_size", v->Size(), 5); TEST("range_erase_range_len", r.Copy()->Size(), 0); } TestSubsection("Range Replacing"); { SVector v, w; for(int i=0; i<15; i++) v[i]=i; for(int i=0; i<5; i++) w[i]=i*100; SVectorRange r(v,3,10); r.Replace(w); TEST("range_replace_less", v->TextRepresentation().c_str(), "#~(0 1 2 0 100 200 300 400 13 14)"); TEST("range_replace_less_size", v->Size(), 10); TEST("range_replace_less_range_len", r.Copy()->Size(), 5); } { SVector v, w; for(int i=0; i<10; i++) v[i]=i; for(int i=0; i<5; i++) w[i]=i*100; SVectorRange r(w,1,2); r.Replace(v); TEST("range_replace_more", w->TextRepresentation().c_str(), "#~(0 0 1 2 3 4 5 6 7 8 9 300 400)"); TEST("range_replace_more_size", w->Size(), 13); TEST("range_replace_more_range_len", r.Copy()->Size(), 10); } TestScore(); } catch(const IntelibX &ex) { printf("Caught IntelibX: %s\n%s\n", ex.Description(), ex.Parameter().GetPtr() ? ex.Parameter()->TextRepresentation().c_str() : ""); } catch(...) { printf("Something strange caught\n"); } poc(); return 0; }
int main() { poc(); #ifdef INTELIB_DEBUG_COUNTERS int before = SExpression::object_counter; #endif try { TestSection("RefalExpressions"); TestSubsection("TextRepresentation"); { RfReference empty(new RfExpression); TESTTR("empty_rfexpr", empty, ""); TESTTR("empty_subexpr", R|~R, "()"); } TestSubsection("Construction"); { TESTTR("single", (R|99), "99"); TESTTR("plain", (R|1,2,3), "1 2 3"); TESTTR("not_plain", (R|1,(R|2), (R|3,4,(R|5,6),7),8), "1 (2) (3 4 (5 6) 7) 8"); TESTTR("with_call", (R|1, R<2, 3, 4>R, 5), "1 <2 3 4> 5"); TESTTR("just_a_call", (R<1,2,3,4>R), "<1 2 3 4>"); TESTTR("just_a_call_1", (R<1>R), "<1>"); TESTTR("just_a_call_2", (R<1,2>R), "<1 2>"); TESTTR("call_in_call", (R<1,2, R<3,4,R<5,6,7>R,8>R,9>R), "<1 2 <3 4 <5 6 7> 8> 9>"); TESTTR("multy_within_expr", (R|1,2,R<1,R<2,R<3,4>R>R>R,5), "1 2 <1 <2 <3 4>>> 5"); } TestSubsection("MultyCallConstructor"); { #if 0 TESTTR("x", (R<R<1), "<#<#1"); TESTTR("xx", (R<R<1, 2), "<#<#1 2"); TESTTR("xxx", (R<R<1, 2>R), "<#<1 2>"); #endif TESTTR("call_in_beginning_of_call", (R<R<1,2>R, 3>R), "<<1 2> 3>"); TESTTR("call_in_beginning_of_call_noclose", (R<R<1,2>R, 3), "<#<1 2> 3"); TESTTR("call_in_beginning_of_call2", (R<R<R<1,2>R, 3>R,4>R), "<<<1 2> 3> 4>"); TESTTR("call_in_beginning_of_call3", (R<R<R<1,2>R,3>R,4>R), "<<<1 2> 3> 4>"); TESTTR("multy_within_expr", (R|1,2,R<R<R<3,4>R>R>R,5), "1 2 <<<3 4>>> 5"); TESTTR("call_starts_with_subexpr", (R|0,R<R<(R|1,2,3),4>R>R,5), "0 <<(1 2 3) 4>> 5"); TESTTR("inner_call_of_one_symbol", (R<R<1>R>R), "<<1>>"); TESTTR("inner_call_of_one_symbol", (R|0,R<R<1>R>R,2), "0 <<1>> 2"); } TestSubsection("Strings decomposition"); { TESTTR("simple_char", (R|"a"), "\"a\""); TESTTR("char_shuffled", (R|1,"a",2), "1 \"a\" 2"); TESTTR("char_shuffled2", (R|"a",2,"b"), "\"a\" 2 \"b\""); TESTTR("char_shuffled3", (R|"a",2,3,"b"), "\"a\" 2 3 \"b\""); TESTTR("char_shuffled4", (R|"a",2,3,"bc"), "\"a\" 2 3 \"bc\""); TESTTR("char_shuffled4", (R|"ab",2,3,"bc"), "\"ab\" 2 3 \"bc\""); TESTTR("char_shuffled4", (R|"ab",(R|2,3),"bc"), "\"ab\" (2 3) \"bc\""); TESTTR("simple_strings", (R|"abcd","efgh","ijkl"), "\"abcdefghijkl\""); TESTTR("strings_in_a_call", (R<"abcd","efgh","ijkl">R), "<\"abcdefghijkl\">"); TESTTR("one_strings_in_many_calls", (R<R<R<"abcd">R>R>R), "<<<\"abcd\">>>"); } TestSubsection("Pairing"); { RfReference r((R|1,(R|2,(R|3,(R|4),5),6),7)); RfListItem *temp1 = r->GetFirst(), *temp2 = r->GetLast(); temp1 = temp1->next; temp2 = temp2->prev; for (int i=0; i<2; i++) { TESTB("paired_lr", temp1->pair == temp2); TESTB("paired_rl", temp2->pair == temp1); temp1 = temp1->next; temp2 = temp2->prev; temp1 = temp1->next; temp2 = temp2->prev; } } TestSubsection("ConvertToLisp"); { RfReference r((R|1,(R|"abcd",(R|3,(R|4),"efgh"),6),7,"i")); SReference r1 = r->ConvertToLisp(); TESTTR("convert_to_lisp", r1, "(1 (\"abcd\" (3 (4) \"efgh\") 6) 7 \"i\")"); } TestSubsection("Memory leaks"); { #ifdef INTELIB_DEBUG_COUNTERS TEST("no_leaks", SExpression::object_counter, before); #endif } TestScore(); } catch(const IntelibX &ex) { printf("Caught IntelibX: %s\n", ex.Description()); doprint(ex.Parameter().GetPtr()); printf("\n"); } catch(...) { printf("Something strange caught\n"); } poc(); return 0; }
int main() { poc(); SLabel A("A"); SExpressionLabel *pa = A.GetPtr(); SLabel B("B"); SExpressionLabel *pb = B.GetPtr(); SLabel C("C"); SExpressionLabel *pc = C.GetPtr(); SLabel D("D"); SExpressionLabel *pd = D.GetPtr(); SLabel E("E"); SExpressionLabel *pe = E.GetPtr(); SLabel F("F"); SExpressionLabel *pf = F.GetPtr(); SExpressionLabel *pall[] = { pa, pb, pc, pd, pe, pf }; try { TestSection("IntelibBindingsSet"); TestSubsection("Creation"); { IntelibBindingsSet t; TESTB("empty0", !t.GetBinding(pa)); TESTB("empty25", !t.GetBinding(pb)); *(t.AddBinding(pb)) = SReference(2525); TESTTR("root_only", *(t.GetBinding(pb)), "2525"); *(t.AddBinding(pc)) = SReference(3636); TESTB("root_still_there", t.GetBinding(pb)); TESTTR("root_still_has_value", *(t.GetBinding(pb)), "2525"); TESTB("second_val_exists", t.GetBinding(pc)); TESTTR("second_val", *(t.GetBinding(pc)), "3636"); TESTB("root_still_there", t.GetBinding(pb)); } TestSubsection("Allocation"); { IntelibBindingsSet t; SReference* loc[4]; for(int i = 0; i < 4; i++) { loc[i] = t.AddBinding(pall[i]); *loc[i] = (i+1) * 1000; } t.AddBinding(pf); SReference *l1 = t.GetBinding(pb); TESTB("still_there_after_resize", l1); TESTTR("still_value_after_resize", *l1, "2000"); SReference *l0 = t.GetBinding(pa); TESTB("root_there_after_resize", l0); TESTTR("root_value_after_resize", *l0, "1000"); //TESTB("resize_really_done", l1 != loc[1]); } TestSubsection("Iterator"); { IntelibBindingsSet t; IntelibBindingsSet::Iterator iter0(t); SReference ref; const SExpressionLabel *key; TESTB("iterator_on_empty", !iter0.GetNext(key, ref)); *(t.AddBinding(pa)) = SReference(2); *(t.AddBinding(pb)) = SReference(20); *(t.AddBinding(pc)) = SReference(200); IntelibBindingsSet::Iterator iter1(t); int sum2 = 0; while(iter1.GetNext(key, ref)) { if(ref.GetPtr()) sum2 += ref.GetInt(); } TEST("iterator_values", sum2, 222); } TestSubsection("LotsOfBindings"); { IntelibBindingsSet t; *(t.AddBinding(pa)) = SReference(1); *(t.AddBinding(pb)) = SReference(2); *(t.AddBinding(pc)) = SReference(3); *(t.AddBinding(pd)) = SReference(4); *(t.AddBinding(pe)) = SReference(5); *(t.AddBinding(pf)) = SReference(6); TESTB("value_there_1", t.GetBinding(pa)); TESTB("value_there_2", t.GetBinding(pb)); TESTB("value_there_3", t.GetBinding(pc)); TESTB("value_there_4", t.GetBinding(pd)); TESTB("value_there_5", t.GetBinding(pe)); TESTB("value_there_6", t.GetBinding(pf)); } TestScore(); } catch(const IntelibX &ex) { printf("Caught IntelibX: %s\n%s\n", ex.Description(), ex.Parameter().GetPtr() ? ex.Parameter()->TextRepresentation().c_str() : "" ); } catch(...) { printf("Something strange caught\n"); } poc(); return 0; }