示例#1
0
文件: main.cpp 项目: yqbk/CPP
int main(void)
{
     cout << "main by kk. Last updated 15.04.2013\n";

     int i_tab[] = {5, 4, 12, -4, 0};
     char c_tab[] = {'\"', 'a', 'b', 'c', 'z', '\"'};
     char* c_ptr_tab[] = {"to", "jest", "moj", "pierwszy", "program", "na" , "zajeciach"};
     aghFib fib;

     bool t1 = suma(i_tab, 5) == 17;
     bool t2 = suma(c_tab, 6) == 484;
     bool t3 = suma(c_ptr_tab, 7) == 35;
     bool t4 = suma(fib, 5) == 7;

     for(int i=0;i<6;i++)
       cout << c_tab[i] << " = " << (int)c_tab[i] << endl;

     showTestResult(1, t1);
     showTestResult(2, t2);
     showTestResult(3, t3);
     showTestResult(4, t4);

     cout << "Finally, this is the end...\n";

     return 0;
}
int main(int argc, const char * argv[]) {
   
    //case 0 - 0 element
    int *arr = NULL;
    int arrLen = (int)sizeof(arr) / sizeof(int);
    showTestResult(arr, arrLen);
    
    //case 1 - one element
    int arr1[1] = {1};
    int arrLen1 = (int)sizeof(arr1) / sizeof(int);
    showTestResult(arr1, arrLen1);
    
    //case 2.1 - two elements, incremented
    int arr2[2] = {1, 100};
    int arrLen2 = (int)sizeof(arr2) / sizeof(int);
    showTestResult(arr2, arrLen2);
    
    //case 2.2 - two elements, decremented
    int arr22[2] = {100, 23};
    int arrLen22 = (int)sizeof(arr22) / sizeof(int);
    showTestResult(arr22, arrLen22);
    
    //case 2.3 - two elements, same
    int arr23[2] = {51,51};
    int arrLen23 = (int)sizeof(arr23) / sizeof(int);
    showTestResult(arr23, arrLen23);
    
    //case 3.1 - many elements, incremented
    int arr3[20] = {1,2,3,4,5,6,7,8,9,50, 61,62,63,64,65,66,67,68,69, 101};
    int arrLen3 = (int)sizeof(arr3) / sizeof(int);
    showTestResult(arr3, arrLen3);

    //case 3.2 - three elements, decremented
    int arr32[20] = {99, 97, 95., 93, 91, 89, 87, 85, 83, 81, 79, 77, 75, 73, 71, 69, 67, 65, 63, 61};
    int arrLen32 = (int)sizeof(arr32) / sizeof(int);
    showTestResult(arr32, arrLen32);
    
    //case 3.3 - three elements, randomed
    int arr33[10] = {33 , 33, 33, 33, 33, 33, 33, 33, 33, 33};
    int arrLen33 = (int)sizeof(arr33) / sizeof(int);
    showTestResult(arr33, arrLen33);
    

    return 0;
}
示例#3
0
int main(void)
{
      aghVector<aghVector<int> > a;
    aghContainer<int>* c1 = new aghVector<int>;
    aghTree<int>* c2;
    a << *((aghVector<int>*)c1);

    // 1st test - dodawanie do pojemnika stalych, zmiennych, tymczasowych
    c1->append(3);
    c1->insert(0, 1+4);
    c1->insert(c1->size(), c1->size());

    bool t1 = c1->size() == 3;
    int ttab1[] = {5, 3, 2};
    for(int i=0;i<3;i++)
        t1 = t1 && (ttab1[i] == c1->at(i));
    showTestResult(1, t1);

    // 2nd test - konstruktor
    c2 = new aghTree<int>(*c1);
    bool t2 = c2->size() == 3;
    int ttab2[] = {2, 3, 5};
    for(int i=0;i<3;i++)
        t2 = t2 && (ttab2[i] == c2->at(i));
    showTestResult(2, t2);

    // 3rd test - odwolania
    try
    {
        c2->at(-1);
        c2->at(100);
        (*c2)[-10];
        (*c2)[100];
        showTestResult(3, true);
    }
    catch(aghException& e)
    {
        showTestResult(3, true);
    }
    catch(...)
    {
        showTestResult(3, false);
    }

    // 4th test - usuwanie z pojemnika
    c2->clear();
    for(int i=0;i<5;i++)
        *c2 += i;
    *c2 << 4 << 2+3 << -5 << 3;
    c2->remove(2);

    int ttab4[] = {-5, 0, 2, 3, 3, 4, 4, 5};
    bool t4 = c2->size() == 8;
    for(int i=0;t4 && i<8;i++)
        t4 = t4 && (ttab4[i] == c2->at(i));
    showTestResult(4, t4);

    // 5th test
    a.at(0).clear();
    a.at(0) << *c2;
    bool t5 = a.at(0).size() == 8;
    int ttab5[] = {-5, 0, 2, 3, 3, 4, 4, 5};
    for(int i=0;i<8;i++)
        t5 = t5 && (ttab5[i] == a.at(0).at(i));
    showTestResult(5, t5);

     // 6th test - metoda indexOf
    showTestResult(6, c2->indexOf(3) == 3);

    // 7th test - metoda indexOf
    showTestResult(7, c2->indexOf(3, 4) == 4);

    // 8th test - metoda indexOf
    showTestResult(8, c2->indexOf(0, 3) == -1);

    // 9th test - metoda contains
    showTestResult(9, !c2->contains(-6));

    // 10th test - sortowanie
    c1->clear();
    bool t10 = (c1->size() == 0) && (c2->size() == 8);
    int ttab10_1[] = {7, -5, 12, 15, 9, -10, -20, -8, 1, -3, 2};
    int ttab10_2[] = {-20, -10, -8, -5, -3, 1, 2, 7, 9, 12, 15};
    for(int i=0;i<11;i++)
        c1->append(ttab10_1[i]);
    for(int i=0;i<11;i++)
        t10 = t10 && (c1->at(i) == ttab10_1[i]);
    *c2 = *c1;
    c1->clear();
    *c1 << *c2;
    for(int i=0;i<11;i++)
        t10 = t10 && (c1->at(i) == ttab10_2[i]);
    showTestResult(10, t10);

      // 11th test - dzialanie operatora przypisania
    a.at(0) = *c1;
    showTestResult(11, a.at(0) == *c2);

    // 12th test - operator przypisania
    *c2 = *c2;
    try
    {
        showTestResult(12, a.at(0) == *c2);
    }
    catch(...)
    {
        showTestResult(12, false);
    }

    // 13th test - usuwanie z pojemnika
    c2->remove(2);    // -8
    c2->remove(0);    // -20
    c2->remove(1);    // -5
    c2->remove(5);    // 9
    c2->remove(5);    // 12
    c2->remove(4);    // 7
    showTestResult(13, c2->size() == 5);

    // 14th test
    bool t14 = c2->size() == 5;
    int ttab14[] = {-10, -3, 1, 2, 15};
    for(int i=0;i<5;i++)
        t14 = t14 && (c2->at(i) == ttab14[i]);
    showTestResult(14, t14);

    // 15th test - zwalnianie paieci
    try
    {
        delete c1;
        delete c2;
        showTestResult(15, true);
    }
    catch(...)
    {
        showTestResult(15, false);
    }
    return 0;
}
示例#4
0
int main(void)
{
    cout << "main by kk. Last updated 20.09.2011\n";

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

    int it1[] = {84, 23, 84, 21, 120, 93, -131, 238}; 
    int it2[] = {249, 24, 82, 3};
    int it3[] = {439, 828, 39, 230, 95, 1, -242, 34};

    aghMatrix<int>* imptr1 = new aghMatrix<int>(2, 4);
    aghMatrix<int>* imptr2 = new aghMatrix<int>(4, 1);
    aghMatrix<int>* imptr3 = new aghMatrix<int>(4, 1);
    aghMatrix<int>* imptr4 = new aghMatrix<int>(2, 4);
    aghMatrix<int> imtest1, imtest2, imtest3;

    imtest1.setItems(4, 1, 249, 24, 82, 3);
    imtest2.setItems(2, 4, 500+23, 851, 123, 251, 215, 94, -373, 272);
    imtest3.setItems(2, 1, 28419, 22084);


    aghMatrix<int>& imref1 = *imptr1;
    aghMatrix<int>& imref2 = *imptr2;
    aghMatrix<int>& imref3 = *imptr3;
    aghMatrix<int>& imref4 = *imptr4;

    imptr1->setItems(it1);
    imptr2->setItems(it2);
    imref3 = imref2;
    imptr4->setItems(it3);

    // 1st test - operator przypisania
    showTestResult(1, imref3 == imtest1);

    // 2nd test - operator przypisania
    try
    {
        imref3 = imref3;
        showTestResult(2, imref3 == imref2);
    }
    catch(...)
    {
        showTestResult(2, false);
    }

    // 3rd test - jawne wywolanie destruktora
    imref2.~aghMatrix();
    try
    {
        showTestResult(3, imref3 != imref2);
    }
    catch(...)
    {
        showTestResult(3, false);
    }

    // 4th test - destruktor
    try
    {
        delete imptr2;
        showTestResult(4, true);
    }
    catch(...)
    {
        showTestResult(4, false);
    }

    // 5th test - kopiowanie wartosci
    showTestResult(5, imref3 == imtest1);

    // 6th test - operator dodawania
    try
    {
        showTestResult(6, (imref1+imref4) == imtest2);
    }
    catch(...)
    {
        showTestResult(6, false);
    }

    // 7th test - operator mnożenia
    aghMatrix<int> immulres;
    try
    {
        aghMatrix<int> immultmp = imref1*imref3;
        immulres = immultmp;
    }
    catch(...)
    {
        showTestResult(7, false);
    }

    showTestResult(7, immulres == imtest3);

    // 8th test - range test
    try
    {
        immulres(10, 11);
        immulres(10, -11);
    }
    catch(aghException& e)
    {
        showTestResult(8, true);
    }
    catch(...)
    {
        showTestResult(8, false);
    }

    // 9th test - dimesion test
    try
    {
        imref1+imref3;
    }
    catch(aghException& e)
    {
        showTestResult(9, true);
    }
    catch(...)
    {
        showTestResult(9, false);
    }

    // 10th test - dimesion test
    try
    {
        imref1*imref4;
    }
    catch(aghException& e)
    {
        showTestResult(10, true);
    }
    catch(...)
    {
        showTestResult(10, false);
    }
    /////////////////////////////////////////////////////

    char ct[] = {'b', 'k', 'l', 'd', 'h', 'z', 'd', 'j', 'z', 'x', 'c', 'n', 'b', 'k', 'z', 'd', 'w'};
    aghMatrix<char> cm1(3, 2);
    aghMatrix<char> cm2(3, 2);
    aghMatrix<char> cm3(2, 4);
    cm1.setItems(ct);
    cm2.setItems(ct+5);
    cm3.setItems(ct+8);

    aghMatrix<char> cmtest1, cmtest2;
    cmtest1.setItems(3, 2, 'a', 'n', 'u', 'c', 'e', 'b');
    cmtest2.setItems(3, 4, 'j', 't', 's', 'r', 's', 'x', 't', 'w', 's', 'v', 'p', 'k');

    // 11th test - operator dodawania
    try
    {
        showTestResult(11, (cm1+cm2) == cmtest1);
    }
    catch(...)
    {
        showTestResult(11, false);
    }

    // 12th test - operator mnożenia
    try
    {
        showTestResult(12, (cm1*cm3) == cmtest2);
    }
    catch(...)
    {
        showTestResult(12, false);
    }
    /////////////////////////////////////////////////////

    char* cpt[] = {"to", "jest", "tablica", "wyrazow", "o", "rozmiarze", "jedenascie", "ktore", "beda", "elementami", "macierzy"};
    aghMatrix<char*> cpm1(2, 3);
    aghMatrix<char*> cpm2(2, 3);
    aghMatrix<char*> cpm3(3, 1);
    aghMatrix<char*> cpm4;
    aghMatrix<char*> cpm5;
    aghMatrix<char*>* cpmptr1 = new aghMatrix<char*>(1, 1);
    aghMatrix<char*> cpmtest1, cpmtest2;

    cpm1.setItems(cpt);
    cpm2.setItems(cpt+5);
    cpm3.setItems(cpt+3);
    cpmptr1->setItem(0, 0, cpt[5]);
    cpmtest1.setItems(2, 3, "torzmiae", "jestdnaci", "tablickore", "wyrazobed", "oelmntai", "rozmiaecy");
    cpmtest2.setItems(2, 1, "oai", "wyrazomie");

    // 13th test - destruktor
    char* itemptr = cpmptr1->operator()(0,0);
    itemptr[0] = 'a';

    delete cpmptr1;
    showTestResult(13, strcmp(itemptr, cpt[5]) != 0);

    // 14th test - operator przypisania p1
    cpm5 = cpm4 = cpm3;
    showTestResult(14, (cpm3 == cpm4) && (cpm3 == cpm5));

    // 15th test - operator przypisania p2
    cpm5.setItem(0, 0, "nothing");
    showTestResult(15, (cpm3 == cpm4) && (cpm3 != cpm5) && (strcmp(cpm3(0,0), "wyrazow") == 0));

    // 16th test - operator przypisania
    cpm5 = cpm3;
    try
    {
        cpm5 = cpm5;

        showTestResult(16, cpm3 == cpm5);

    }
    catch(...)
    {
        showTestResult(16, false);
    }

    // 17th test - jawne wywolanie destruktora
    cpm5 = cpm3;
    cpm5.~aghMatrix();
    try
    {
        showTestResult(17, (cpm3 != cpm5));
    }
    catch(...)
    {
        showTestResult(17, false);
    }

    // 18th test - operator dodawania
    try
    {
        showTestResult(18, (cpm1+cpm2) == cpmtest1);
    }
    catch(...)
    {
        showTestResult(18, false);
    }
    // 19th test - operator mnożenia
    try
    {
        showTestResult(19, (cpm1*cpm3) == cpmtest2);
    }
    catch(...)
    {
        showTestResult(19, false);
    }
    /////////////////////////////////////////////////////

    aghComplex cmplxt1[] = {aghComplex(1,1), aghComplex(1,2), aghComplex(2,1), aghComplex(2,2), aghComplex(3,3), aghComplex(3,1), aghComplex(1,0), aghComplex(0,1)};
    aghComplex cmplxt2[] = {aghComplex(-1,2), aghComplex(0,3), aghComplex(2,6), aghComplex(3,2), aghComplex(3,4)};
    aghMatrix<aghComplex> cmplxm1(3, 2);
    aghMatrix<aghComplex> cmplxm2(2, 1);
    aghMatrix<aghComplex> cmplxm3(2, 1);
    aghMatrix<aghComplex> cmplxm4(2, 1);
    aghMatrix<aghComplex> cmplxmtest1(3, 1);
    aghMatrix<aghComplex> cmplxmtest2(2, 1);

    cmplxm1.setItems(cmplxt1);
    cmplxm2.setItems(cmplxt1+6);
    cmplxm3.setItems(cmplxt1+3);

    cmplxmtest1.setItems(cmplxt2);
    cmplxmtest2.setItems(cmplxt2+3);
    cmplxm4 = cmplxm2 + cmplxm3;

    // 20th test - operator dodawania
    try
    {
        showTestResult(20, cmplxm4 == cmplxmtest2);
    }
    catch(...)
    {
        showTestResult(20, false);
    }
    // 21th test - operator mnozenia
    try
    {
        showTestResult(21, (cmplxm1*cmplxm2) == cmplxmtest1);
    }
    catch(...)
    {
        showTestResult(21, false);
    }
    /////////////////////////////////////////////////////

    cout << "Finally, this is the end...\n";
    return 0;
}
示例#5
0
文件: ex4main.cpp 项目: kao194/JiMP
int main(void)
{
    cout << "main by kk. Last updated 15.04.2013\n";
    aghVector<aghVector<int> > a;
    aghContainer<int>* c1 = new aghVector<int>;
    aghContainer<int>* c2;
    a << *((aghVector<int>*)c1);

    // 1st test - dodawanie do pojemnika stalych, zmiennych, tymczasowych
    c1->append(3);
    c1->insert(0, 1+1);
    c1->insert(c1->size(), c1->size());

    bool t1 = c1->size() == 3;
    int ttab1[] = {2, 3, 2};
    for(int i=0;i<3;i++)
        t1 = t1 && (ttab1[i] == c1->at(i));
    showTestResult(1, t1);

    // 2nd test - konstruktor
    c2 = new aghVector<int>(*c1);
    bool t2 = c2->size() == 3;
    int ttab2[] = {2, 3, 2};
    for(int i=0;i<3;i++)
        t2 = t2 && (ttab2[i] == c2->at(i));
    showTestResult(2, t2);

    // 3rd test - odwolania
    try
    {
        c2->at(-1);
        c2->at(100);
        c2->at(c2->size());
        (*c2)[-10];
        (*c2)[100];
        showTestResult(3, true);
    }
    catch(aghException& e)
    {
        showTestResult(3, true);
    }
    catch(...)
    {
        showTestResult(3, false);
    }

    // 4th test - usuwanie z pojemnika
    c1->clear();
    for(int i=0;i<5;i++)
        *c1 += i;
    *c1 << 4 << 2+3;
    c1->remove(2);

    int ttab4[] = {0, 1, 3, 4, 4, 5};
    bool t4 = c1->size() == 6;
    for(int i=0;t4 && i<6;i++)
        t4 = t4 && (ttab4[i] == c1->at(i));
    showTestResult(4, t4);

    // 5th test - sprawdzenie dzialanie konstruktora kopiujacego
    bool t5 = c2->size() == 3;
    int ttab5[] = {2, 3, 2};
    for(int i=0;i<3;i++)
        t5 = t5 && (ttab5[i] == c2->at(i));
    showTestResult(5, t5);

    // 6th test - metoda indexOf
    showTestResult(6, c1->indexOf(3) == 2);

    // 7th test - metoda indexOf
    showTestResult(7, c1->indexOf(4, 3) == 3);

    // 8th test - metoda indexOf
    showTestResult(8, c1->indexOf(4, 4) == 4);

    // 9th test - metoda indexOf
    showTestResult(9, c1->indexOf(3, 3) == -1);

    // 10th test - metoda contains
    showTestResult(10, !c1->contains(-6));


    // 11th test - operacje na pojemniku w pojemniku
    for(int i=3;i>=0;i--)
        a.at(0) += i+1;

    bool t11 = a.at(0).size() == 4;
    int ttab11[] = {4, 3, 2, 1};
    for(int i=0;t11 && i<4;i++)
        t11 = t11 && (a.at(0).at(i) == ttab11[i]);
    showTestResult(11, t11);

    // 12th test - usuwanie z pojemnika
    a.at(0).remove(2);   // 4,3,1
    a.at(0).remove(1);   // 4,1
    a.at(0).remove(1);   // 4
    a.at(0).remove(0);   // empty
    showTestResult(12, a.at(0).isEmpty());

    // 13th test - dzialanie operatora przypisania
    *c2  = a.at(0) = *c1;
    showTestResult(13, *c1 == a.at(0));

    // 14th test - operator przypisania
    try
    {
        *c2 = *c2;
        showTestResult(14, *c1 == *c2);
    }
    catch(...)
    {
        showTestResult(14, false);
    }

    // 15th test - zwalnianie paieci
    try
    {
        delete c1;
        delete c2;
        showTestResult(15, true);
    }
    catch(...)
    {
        showTestResult(15, false);
    }

    cout << "Finally, this is the end...\n";

    return 0;
}
示例#6
0
文件: main.cpp 项目: KayJay624/JiMP
int main(void)
{
    cout << "main by kk. Last updated 20.09.2011\n";

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

    int it1[] = {84, 23, 84, 21, 120, 93, -131, 238};
    int it2[] = {249, 24, 82, 3};
    int it3[] = {439, 828, 39, 230, 95, 1, -242, 34};

    aghMatrix<int>* imptr1 = new aghMatrix<int>(2, 4);
    aghMatrix<int>* imptr2 = new aghMatrix<int>(4, 1);
    aghMatrix<int>* imptr3 = new aghMatrix<int>(4, 1);
    aghMatrix<int>* imptr4 = new aghMatrix<int>(2, 4);
    aghMatrix<int> imtest1, imtest2, imtest3;

    imtest1.setItems(4, 1, 249, 24, 82, 3);
    imtest2.setItems(2, 4, 500+23, 851, 123, 251, 215, 94, -373, 272);
    imtest3.setItems(2, 1, 28419, 22084);

    aghMatrix<int>& imref1 = *imptr1;
    aghMatrix<int>& imref2 = *imptr2;
    aghMatrix<int>& imref3 = *imptr3;
    aghMatrix<int>& imref4 = *imptr4;

    imptr1->setItems(it1);
    imptr2->setItems(it2);
    imref3 = imref2;
    imptr4->setItems(it3);


    // 1st test - operator przypisania
    showTestResult(1, imref3 == imtest1);

    // 2nd test - operator przypisania
    try
    {
        imref3 = imref3;

        showTestResult(2, imref3 == imref2);
    }
    catch(...)
    {
        showTestResult(2, false);
    }

    // 3rd test - jawne wywolanie destruktora
    imref2.~aghMatrix();
    try
    {
        showTestResult(3, imref3 != imref2);
    }
    catch(...)
    {
        showTestResult(3, false);
    }

    // 4th test - destruktor
    //try
    //{
     //   delete imptr2;
     //   showTestResult(4, true);
    //}
    //catch(...)
    //{
    //    showTestResult(4, false);
    //}

    // 5th test - kopiowanie wartosci
    showTestResult(5, imref3 == imtest1);

    // 6th test - operator dodawania
    try
    {
        showTestResult(6, (imref1+imref4) == imtest2);


    }
    catch(...)
    {
        showTestResult(6, false);
    }

    return 0;
}