Download Reference Manual
The Developer's Library for D
About Wiki Forums Source Search Contact

Ticket #228: HashSet.patch

File HashSet.patch, 12.5 kB (added by dhasenan, 1 year ago)

patch for requested single-threaded unittests for HashSet?

  • HashSet.d

    old new  
    550550        } 
    551551} 
    552552 
     553version (UnitTest) 
     554{ 
     555        /* Primitives ***********************/ 
     556        /* Add contains */ 
     557        unittest 
     558        { 
     559                auto set = new HashSet!(int)(); 
     560                set.add(4); 
     561                set.add(5); 
     562                assert (set.contains(4), "added item not found"); 
     563                assert (set.contains(5), "added item not found"); 
     564        } 
     565        /* Remove contains */ 
     566        unittest 
     567        { 
     568                auto set = new HashSet!(int)(); 
     569                set.add(4); 
     570                set.add(5); 
     571                set.remove(4); 
     572                assert (!set.contains(4), "failed to remove item");  
     573                set.remove(5); 
     574                assert (!set.contains(5), "failed to remove item"); 
     575        } 
     576        /* count */ 
     577        unittest 
     578        { 
     579                auto set = new HashSet!(int)(); 
     580                set.add(4); 
     581                assert (set.size == 1, "count not updated"); 
     582                set.add(5); 
     583                assert (set.size == 2, "count not updated"); 
     584                set.remove(4); 
     585                assert (set.size == 1, "count not updated");  
     586        } 
     587        /* opApply */ 
     588        unittest 
     589        { 
     590                int fiveFound = 0; 
     591                int elevenFound = 0; 
     592                auto set = new HashSet!(int)(); 
     593                set.add(11); 
     594                set.add(5);  
    553595 
     596                foreach (i; set) 
     597                { 
     598                        if (i == 5) 
     599                        { 
     600                                fiveFound++; 
     601                        } 
     602                        else if (i == 11) 
     603                        { 
     604                                elevenFound++; 
     605                        } 
     606                        else 
     607                        { 
     608                                assert (false, "found an element not in set"); 
     609                        } 
     610                } 
    554611 
     612                assert (fiveFound <= 1, "encountered element too many times"); 
     613                assert (fiveFound >= 1, "encountered element too few times"); 
     614                assert (elevenFound <= 1, "encountered element too many times"); 
     615                assert (elevenFound >= 1, "encountered element too few times"); 
     616        } 
     617        /* clear */ 
     618        unittest 
     619        { 
     620                auto set = new HashSet!(int)(); 
     621                set.add(1); 
     622                set.add(2); 
     623                set.add(3); 
     624                assert (set.size == 3, "too few elements"); 
     625                set.clear(); 
     626                assert (set.size == 0, "did not clear all elements"); 
     627        } 
     628 
     629        struct Stub 
     630        { 
     631                int i; 
     632                char j; 
     633                static Stub opCall(int a, char b) 
     634                { 
     635                        Stub stub; 
     636                        stub.i = a; 
     637                        stub.j = b; 
     638                        return stub; 
     639                } 
     640 
     641                bool opEquals(Stub other) 
     642                { 
     643                        return i == other.i && j == other.j; 
     644                } 
     645        } 
     646 
     647        /* Structs ***********************/ 
     648        /* Add contains */ 
     649        unittest 
     650        { 
     651                auto set = new HashSet!(Stub)(); 
     652                set.add(Stub(4, 'a')); 
     653                set.add(Stub(71, 'b')); 
     654                assert (set.contains(Stub(4, 'a')), "added item not found"); 
     655                assert (set.contains(Stub(71, 'b')), "added item not found"); 
     656        } 
     657        /* Remove contains */ 
     658        unittest 
     659        { 
     660                auto set = new HashSet!(Stub)(); 
     661                set.add(Stub(4, 'a')); 
     662                set.add(Stub(71, 'b')); 
     663                set.remove(Stub(4, 'a')); 
     664                assert (!set.contains(Stub(4, 'a')), "failed to remove item");  
     665                set.remove(Stub(71, 'b')); 
     666                assert (!set.contains(Stub(71, 'b')), "failed to remove item"); 
     667        } 
     668        /* count */ 
     669        unittest 
     670        { 
     671                auto set = new HashSet!(Stub)(); 
     672                set.add(Stub(4, 'a')); 
     673                assert (set.size == 1, "count not updated"); 
     674                set.add(Stub(71, 'b')); 
     675                assert (set.size == 2, "count not updated"); 
     676                set.remove(Stub(4, 'a')); 
     677                assert (set.size == 1, "count not updated");  
     678        } 
     679        /* opApply */ 
     680        unittest 
     681        { 
     682                int fiveFound = 0; 
     683                int elevenFound = 0; 
     684                auto set = new HashSet!(Stub)(); 
     685                set.add(Stub(11, '&')); 
     686                set.add(Stub(71, 'b'));  
     687 
     688                foreach (i; set) 
     689                { 
     690                        if (i == Stub(71, 'b')) 
     691                        { 
     692                                fiveFound++; 
     693                        } 
     694                        else if (i == Stub(11, '&')) 
     695                        { 
     696                                elevenFound++; 
     697                        } 
     698                        else 
     699                        { 
     700                                assert (false, "found an element not in set"); 
     701                        } 
     702                } 
     703 
     704                assert (fiveFound <= 1, "encountered element too many times"); 
     705                assert (fiveFound >= 1, "encountered element too few times"); 
     706                assert (elevenFound <= 1, "encountered element too many times"); 
     707                assert (elevenFound >= 1, "encountered element too few times"); 
     708        } 
     709        /* clear */ 
     710        unittest 
     711        { 
     712                auto set = new HashSet!(Stub)(); 
     713                set.add(Stub(1, '8')); 
     714                set.add(Stub(5, 'b')); 
     715                set.add(Stub(0x23, '^')); 
     716                assert (set.size == 3, "too few elements"); 
     717                set.clear(); 
     718                assert (set.size == 0, "did not clear all elements"); 
     719        } 
     720 
     721        class StubClass 
     722        { 
     723                int a; 
     724                char c; 
     725                this (int i, char j) { 
     726                        a = i; 
     727                        c = j; 
     728                } 
     729        } 
     730 
     731        /* Classes ***********************/ 
     732        /* Add contains */ 
     733        unittest 
     734        { 
     735                auto set = new HashSet!(StubClass)(); 
     736                StubClass a = new StubClass(4, 'a'); 
     737                StubClass b = new StubClass(71, 'b'); 
     738                set.add(a); 
     739                set.add(b); 
     740                assert (set.contains(a), "added item not found"); 
     741                assert (set.contains(b), "added item not found"); 
     742        } 
     743        /* Remove contains */ 
     744        unittest 
     745        { 
     746                auto set = new HashSet!(StubClass)(); 
     747                StubClass a = new StubClass(4, 'a'); 
     748                StubClass b = new StubClass(71, 'b'); 
     749                set.add(a); 
     750                set.add(b); 
     751                set.remove(a); 
     752                assert (!set.contains(a), "failed to remove item");  
     753                assert (set.contains(b), "removed too much");  
     754                set.remove(b); 
     755                assert (!set.contains(b), "failed to remove item"); 
     756        } 
     757        /* count */ 
     758        unittest 
     759        { 
     760                auto set = new HashSet!(StubClass)(); 
     761                StubClass a = new StubClass(4, 'b'); 
     762                set.add(a); 
     763                assert (set.size == 1, "count not updated"); 
     764                StubClass b = new StubClass(71, 'b'); 
     765                set.add(b); 
     766                assert (set.size == 2, "count not updated"); 
     767                set.remove(b); 
     768                assert (set.size == 1, "count not updated");  
     769        } 
     770        /* opApply */ 
     771        unittest 
     772        { 
     773                int aFound = 0; 
     774                int bFound = 0; 
     775                auto set = new HashSet!(StubClass)(); 
     776                StubClass a = new StubClass(11, ' '); 
     777                StubClass b = new StubClass(71, 'b'); 
     778                set.add(a); 
     779                set.add(b); 
     780 
     781                foreach (i; set) 
     782                { 
     783                        if (i == a) 
     784                        { 
     785                                aFound++; 
     786                        } 
     787                        else if (i == b) 
     788                        { 
     789                                bFound++; 
     790                        } 
     791                        else 
     792                        { 
     793                                assert (false, "found an element not in set"); 
     794                        } 
     795                } 
     796 
     797                assert (aFound <= 1, "encountered element too many times"); 
     798                assert (aFound >= 1, "encountered element too few times"); 
     799                assert (bFound <= 1, "encountered element too many times"); 
     800                assert (bFound >= 1, "encountered element too few times"); 
     801        } 
     802        /* clear */ 
     803        unittest 
     804        { 
     805                auto set = new HashSet!(StubClass)(); 
     806                set.add(new StubClass(77777, 'a')); 
     807                set.add(new StubClass(77778, '0')); 
     808                set.add(new StubClass(77779, 'Z')); 
     809                assert (set.size == 3, "too few elements"); 
     810                set.clear(); 
     811                assert (set.size == 0, "did not clear all elements"); 
     812        } 
     813 
     814        interface IStub {} 
     815        class StubImpl : IStub 
     816        { 
     817                int a, b; 
     818                this (int i, int j) 
     819                { 
     820                        a = i; 
     821                        b = 7 * j - 2; 
     822                } 
     823        } 
     824 
     825        /* Interfaces ***********************/ 
     826        /* Add contains */ 
     827        unittest 
     828        { 
     829                auto set = new HashSet!(IStub)(); 
     830                IStub a = new StubImpl(4, 'a'); 
     831                IStub b = new StubImpl(71, 'b'); 
     832                set.add(a); 
     833                set.add(b); 
     834                assert (set.contains(a), "added item not found"); 
     835                assert (set.contains(b), "added item not found"); 
     836        } 
     837        /* Remove contains */ 
     838        unittest 
     839        { 
     840                auto set = new HashSet!(IStub)(); 
     841                IStub a = new StubImpl(4, 'a'); 
     842                IStub b = new StubImpl(71, 'b'); 
     843                set.add(a); 
     844                set.add(b); 
     845                set.remove(a); 
     846                assert (!set.contains(a), "failed to remove item");  
     847                assert (set.contains(b), "removed too much");  
     848                set.remove(b); 
     849                assert (!set.contains(b), "failed to remove item"); 
     850        } 
     851        /* count */ 
     852        unittest 
     853        { 
     854                auto set = new HashSet!(IStub)(); 
     855                IStub a = new StubImpl(4, 'b'); 
     856                set.add(a); 
     857                assert (set.size == 1, "count not updated"); 
     858                IStub b = new StubImpl(71, 'b'); 
     859                set.add(b); 
     860                assert (set.size == 2, "count not updated"); 
     861                set.remove(b); 
     862                assert (set.size == 1, "count not updated");  
     863        } 
     864        /* opApply */ 
     865        unittest 
     866        { 
     867                int aFound = 0; 
     868                int bFound = 0; 
     869                auto set = new HashSet!(IStub)(); 
     870                IStub a = new StubImpl(11, ' '); 
     871                IStub b = new StubImpl(71, 'b'); 
     872                set.add(a); 
     873                set.add(b); 
     874 
     875                foreach (i; set) 
     876                { 
     877                        if (i == a) 
     878                        { 
     879                                aFound++; 
     880                        } 
     881                        else if (i == b) 
     882                        { 
     883                                bFound++; 
     884                        } 
     885                        else 
     886                        { 
     887                                assert (false, "found an element not in set"); 
     888                        } 
     889                } 
     890 
     891                assert (aFound <= 1, "encountered element too many times"); 
     892                assert (aFound >= 1, "encountered element too few times"); 
     893                assert (bFound <= 1, "encountered element too many times"); 
     894                assert (bFound >= 1, "encountered element too few times"); 
     895        } 
     896        /* clear */ 
     897        unittest 
     898        { 
     899                auto set = new HashSet!(IStub)(); 
     900                set.add(new StubImpl(77777, 'a')); 
     901                set.add(new StubImpl(77778, '0')); 
     902                set.add(new StubImpl(77779, 'Z')); 
     903                assert (set.size == 3, "too few elements"); 
     904                set.clear(); 
     905                assert (set.size == 0, "did not clear all elements"); 
     906        } 
     907} 
     908 
     909 
    555910debug (Test) 
    556911{ 
    557912        import tango.io.Console;