← Back to branch summary

~ubuntu-branches/ubuntu/precise/judy/precise

« back to all changes in this revision

Viewing changes to test/Judy1LHCheck.c

  • Committer: Bazaar Package Importer
  • Author(s): Troy Heber
  • Date: 2006-06-11 15:58:14 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060611155814-n3j1fvfd5eb5h1zs
Tags: 1.0.3-2

* Resolves #372525, remove .shlibs
* Policy update
* Updated FSF address in copyright

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/Judy1LHCheck.c
17
17
#define FAILURE(STR, UL)                                                \
18
18
{                                                                       \
19
19
printf(         "Error: %s %lu, file='%s', 'function='%s', line %d\n",  \
20
 
        STR, UL, __FILE__, __FUNCTI0N__, __LINE__);                     \
 
20
        STR, (Word_t)(UL), __FILE__, __FUNCTI0N__, __LINE__);           \
21
21
fprintf(stderr, "Error: %s %lu, file='%s', 'function='%s', line %d\n",  \
22
 
        STR, UL, __FILE__, __FUNCTI0N__, __LINE__);                     \
 
22
        STR, (Word_t)(UL), __FILE__, __FUNCTI0N__, __LINE__);           \
23
23
        exit(1);                                                        \
24
24
}
25
25
 
216
216
    Word_t Groups;              // Number of measurement groups
217
217
    Word_t grp;
218
218
 
219
 
    char c;
 
219
    int    c;
220
220
    extern char *optarg;
221
221
 
222
222
//////////////////////////////////////////////////////////////
406
406
            TestJudyCount(J1, JL, LowIndex, Delta);
407
407
        }
408
408
//      Test JLN, J1N
409
 
        HighIndex = TestJudyNext(J1, JL, LowIndex, Delta);
 
409
        HighIndex = TestJudyNext(J1, JL, 0UL, TotalPop);
410
410
 
411
411
//      Test JLP, J1P
412
 
        TestJudyPrev(J1, JL, HighIndex, Delta);
 
412
        TestJudyPrev(J1, JL, ~0UL, TotalPop);
413
413
 
414
414
//      Test JLNE, J1NE
415
415
        TestJudyNextEmpty(J1, JL, LowIndex, Delta);
604
604
 
605
605
        J1T(Rcode, J1, TstIndex);
606
606
        if (Rcode != 1)
607
 
            FAILURE("Judy1Test Rcode != 1", (Word_t) Rcode);
 
607
            FAILURE("Judy1Test Rcode != 1", Rcode);
608
608
 
609
609
        JLG(PValue, JL, TstIndex);
610
610
        if (PValue == (Word_t *) NULL)
649
649
 
650
650
        J1S(Rcode, *J1, TstIndex);
651
651
        if (Rcode != 0)
652
 
            FAILURE("Judy1Set Rcode != 0", (Word_t) Rcode);
 
652
            FAILURE("Judy1Set Rcode != 0", Rcode);
653
653
 
654
654
        JLI(PValue, *JL, TstIndex);
655
655
        if (PValue == (Word_t *) NULL)
683
683
    {
684
684
        J1C(Count1, J1, LowIndex, TstIndex);
685
685
        if (Count1 == JERR)
686
 
            FAILURE("Judy1Count ret JERR", (Word_t) Count1);
 
686
            FAILURE("Judy1Count ret JERR", Count1);
687
687
 
688
688
        if (Count1 != (elm + 1))
689
689
        {
702
702
 
703
703
        JLC(CountL, JL, LowIndex, TstIndex);
704
704
        if (CountL == JERR)
705
 
            FAILURE("JudyLCount ret JERR", (Word_t) CountL);
 
705
            FAILURE("JudyLCount ret JERR", CountL);
706
706
 
707
707
        if (CountL != (elm + 1)) FAILURE("JLC at", elm);
708
708
 
732
732
        if (PValue == NULL)
733
733
            FAILURE("JudyLNext ret NULL PValue at", elm);
734
734
        if (Rcode != 1)
735
 
            FAILURE("Judy1Next Rcode != 1 =", (Word_t) Rcode);
 
735
            FAILURE("Judy1Next Rcode != 1 =", Rcode);
736
736
        if (JLindex != J1index)
737
 
            FAILURE("Judy1Next & Judy1Next ret different PIndex at", elm);
 
737
            FAILURE("JudyLNext & Judy1Next ret different PIndex at", elm);
738
738
 
739
739
        JLN(PValue, JL, JLindex);       // Get next one
740
740
        J1N(Rcode, J1, J1index);        // Get next one
741
741
    }
 
742
 
 
743
    if (PValue != NULL)
 
744
        FAILURE("JudyLNext PValue != NULL", PValue);
 
745
    if (Rcode != 0)
 
746
        FAILURE("Judy1Next Rcode != 1 =", Rcode);
 
747
 
742
748
//  perhaps a check should be done here -- if I knew what to expect.
743
749
    return(JLindex);            // return last one
744
750
}
766
772
        if (PValue == NULL)
767
773
            FAILURE("JudyLPrev ret NULL PValue at", elm);
768
774
        if (Rcode != 1)
769
 
            FAILURE("Judy1Prev Rcode != 1 =", (Word_t) Rcode);
 
775
            FAILURE("Judy1Prev Rcode != 1 =", Rcode);
770
776
        if (JLindex != J1index)
771
 
            FAILURE("Judy1Prev & Judy1Prev ret different PIndex at", elm);
 
777
            FAILURE("JudyLPrev & Judy1Prev ret different PIndex at", elm);
772
778
 
773
779
        JLP(PValue, JL, JLindex);       // Get previous one
774
780
        J1P(Rcode, J1, J1index);        // Get previous one
775
781
    }
 
782
    if (PValue != NULL)
 
783
        FAILURE("JudyLPrev PValue != NULL", PValue);
 
784
    if (Rcode != 0)
 
785
        FAILURE("Judy1Prev Rcode != 1 =", Rcode);
776
786
//  perhaps a check should be done here -- if I knew what to expect.
777
787
    return(0);
778
788
}
800
810
//      Find next Empty Index, JLindex is modified by JLNE
801
811
        JLNE(Rcode, JL, JLindex);       // Rcode = JudyLNextEmpty(JL, &JLindex, PJE0)
802
812
        if (Rcode != 1)
803
 
            FAILURE("JudyLNextEmpty Rcode != 1 =", (Word_t) Rcode);
 
813
            FAILURE("JudyLNextEmpty Rcode != 1 =", Rcode);
804
814
 
805
815
        if (pFlag) { printf("JNE: %8lu\t0x%lx\n", elm, JLindex); }
806
816
 
807
817
//      Find next Empty Index, J1index is modified by J1NE
808
818
        J1NE(Rcode, J1, J1index);       // Rcode = Judy1NextEmpty(J1, &J1index, PJE0)
809
819
        if (Rcode != 1)
810
 
            FAILURE("Judy1NextEmpty Rcode != 1 =", (Word_t) Rcode);
 
820
            FAILURE("Judy1NextEmpty Rcode != 1 =", Rcode);
811
821
 
812
822
        if (J1index != JLindex)
813
823
            FAILURE("JLNE != J1NE returned index at", elm);
850
860
 
851
861
        J1PE(Rcode, J1, J1index);       // Rcode = Judy1PrevEmpty(J1, &J1index, PJE0)
852
862
        if (Rcode != 1)
853
 
            FAILURE("Judy1PrevEmpty Rcode != 1 =", (Word_t) Rcode);
 
863
            FAILURE("Judy1PrevEmpty Rcode != 1 =", Rcode);
854
864
 
855
865
        if (pFlag) { printf("JPE: %8lu\t0x%lx\n", elm, J1index); }
856
866
 
857
867
//      Find next Empty Index, JLindex is modified by JLPE
858
868
        JLPE(Rcode, JL, JLindex);       // Rcode = JudyLPrevEmpty(JL, &JLindex, PJE0)
859
869
        if (Rcode != 1)
860
 
            FAILURE("JudyLPrevEmpty Rcode != 1 =", (Word_t) Rcode);
 
870
            FAILURE("JudyLPrevEmpty Rcode != 1 =", Rcode);
861
871
 
862
872
        if (J1index != JLindex)
863
873
            FAILURE("JLPE != J1PE returned index at", elm);
903
913
 
904
914
        J1U(Rcode, *J1, TstIndex);
905
915
        if (Rcode != 1)
906
 
            FAILURE("Judy1Unset ret Rcode != 1", (Word_t) Rcode);
 
916
            FAILURE("Judy1Unset ret Rcode != 1", Rcode);
907
917
 
908
918
        JLD(Rcode, *JL, TstIndex);
909
919
        if (Rcode != 1)
910
 
            FAILURE("JudyLDel ret Rcode != 1", (Word_t) Rcode);
 
920
            FAILURE("JudyLDel ret Rcode != 1", Rcode);
911
921
 
912
922
        JHSD(Rcode, *JH, (void *)(&TstIndex), sizeof(Word_t));
913
923
        if (Rcode != 1)
914
 
            FAILURE("JudyHSDel ret Rcode != 1", (Word_t) Rcode);
 
924
            FAILURE("JudyHSDel ret Rcode != 1", Rcode);
915
925
 
916
926
        TotalPop--;
917
927
    }