The Tor Browser / file revision

mfbt/tests/TestEnumSet.cpp@925c144e1f1f

mfbt/tests/TestEnumSet.cpp

Fri, 16 Jan 2015 18:13:44 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Fri, 16 Jan 2015 18:13:44 +0100
branch
TOR_BUG_9701
changeset 14
925c144e1f1f
permissions
-rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,

     4  * You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 

     6 #include "mozilla/EnumSet.h"

     7 

     8 using namespace mozilla;

     9 

    10 enum SeaBird {

    11   PENGUIN,

    12   ALBATROSS,

    13   FULMAR,

    14   PRION,

    15   SHEARWATER,

    16   GADFLY_PETREL,

    17   TRUE_PETREL,

    18   DIVING_PETREL,

    19   STORM_PETREL,

    20   PELICAN,

    21   GANNET,

    22   BOOBY,

    23   CORMORANT,

    24   FRIGATEBIRD,

    25   TROPICBIRD,

    26   SKUA,

    27   GULL,

    28   TERN,

    29   SKIMMER,

    30   AUK

    31 };

    32 

    33 class EnumSetSuite {

    34   public:

    35     EnumSetSuite()

    36       : mAlcidae(),

    37         mDiomedeidae(ALBATROSS),

    38         mPetrelProcellariidae(GADFLY_PETREL, TRUE_PETREL),

    39         mNonPetrelProcellariidae(FULMAR, PRION, SHEARWATER),

    40         mPetrels(GADFLY_PETREL, TRUE_PETREL, DIVING_PETREL, STORM_PETREL)

    41     { }

    42 

    43     void runTests() {

    44       testSize();

    45       testContains();

    46       testAddTo();

    47       testAdd();

    48       testAddAll();

    49       testUnion();

    50       testRemoveFrom();

    51       testRemove();

    52       testRemoveAllFrom();

    53       testRemoveAll();

    54       testIntersect();

    55       testInsersection();

    56       testEquality();

    57       testDuplicates();

    58     }

    59 

    60   private:

    61     void testSize() {

    62       MOZ_RELEASE_ASSERT(mAlcidae.size() == 0);

    63       MOZ_RELEASE_ASSERT(mDiomedeidae.size() == 1);

    64       MOZ_RELEASE_ASSERT(mPetrelProcellariidae.size() == 2);

    65       MOZ_RELEASE_ASSERT(mNonPetrelProcellariidae.size() == 3);

    66       MOZ_RELEASE_ASSERT(mPetrels.size() == 4);

    67     }

    68 

    69     void testContains() {

    70       MOZ_RELEASE_ASSERT(!mPetrels.contains(PENGUIN));

    71       MOZ_RELEASE_ASSERT(!mPetrels.contains(ALBATROSS));

    72       MOZ_RELEASE_ASSERT(!mPetrels.contains(FULMAR));

    73       MOZ_RELEASE_ASSERT(!mPetrels.contains(PRION));

    74       MOZ_RELEASE_ASSERT(!mPetrels.contains(SHEARWATER));

    75       MOZ_RELEASE_ASSERT(mPetrels.contains(GADFLY_PETREL));

    76       MOZ_RELEASE_ASSERT(mPetrels.contains(TRUE_PETREL));

    77       MOZ_RELEASE_ASSERT(mPetrels.contains(DIVING_PETREL));

    78       MOZ_RELEASE_ASSERT(mPetrels.contains(STORM_PETREL));

    79       MOZ_RELEASE_ASSERT(!mPetrels.contains(PELICAN));

    80       MOZ_RELEASE_ASSERT(!mPetrels.contains(GANNET));

    81       MOZ_RELEASE_ASSERT(!mPetrels.contains(BOOBY));

    82       MOZ_RELEASE_ASSERT(!mPetrels.contains(CORMORANT));

    83       MOZ_RELEASE_ASSERT(!mPetrels.contains(FRIGATEBIRD));

    84       MOZ_RELEASE_ASSERT(!mPetrels.contains(TROPICBIRD));

    85       MOZ_RELEASE_ASSERT(!mPetrels.contains(SKUA));

    86       MOZ_RELEASE_ASSERT(!mPetrels.contains(GULL));

    87       MOZ_RELEASE_ASSERT(!mPetrels.contains(TERN));

    88       MOZ_RELEASE_ASSERT(!mPetrels.contains(SKIMMER));

    89       MOZ_RELEASE_ASSERT(!mPetrels.contains(AUK));

    90     }

    91 

    92     void testCopy() {

    93       EnumSet<SeaBird> likes = mPetrels;

    94       likes -= TRUE_PETREL;

    95       MOZ_RELEASE_ASSERT(mPetrels.size() == 4);

    96       MOZ_RELEASE_ASSERT(mPetrels.contains(TRUE_PETREL));

    97 

    98       MOZ_RELEASE_ASSERT(likes.size() == 3);

    99       MOZ_RELEASE_ASSERT(likes.contains(GADFLY_PETREL));

   100       MOZ_RELEASE_ASSERT(likes.contains(DIVING_PETREL));

   101       MOZ_RELEASE_ASSERT(likes.contains(STORM_PETREL));

   102     }

   103 

   104     void testAddTo() {

   105       EnumSet<SeaBird> seen = mPetrels;

   106       seen += CORMORANT;

   107       seen += TRUE_PETREL;

   108       MOZ_RELEASE_ASSERT(mPetrels.size() == 4);

   109       MOZ_RELEASE_ASSERT(!mPetrels.contains(CORMORANT));

   110       MOZ_RELEASE_ASSERT(seen.size() == 5);

   111       MOZ_RELEASE_ASSERT(seen.contains(GADFLY_PETREL));

   112       MOZ_RELEASE_ASSERT(seen.contains(TRUE_PETREL));

   113       MOZ_RELEASE_ASSERT(seen.contains(DIVING_PETREL));

   114       MOZ_RELEASE_ASSERT(seen.contains(STORM_PETREL));

   115       MOZ_RELEASE_ASSERT(seen.contains(CORMORANT));

   116     }

   117 

   118     void testAdd() {

   119       EnumSet<SeaBird> seen = mPetrels + CORMORANT +

   120                                          STORM_PETREL;

   121       MOZ_RELEASE_ASSERT(mPetrels.size() == 4);

   122       MOZ_RELEASE_ASSERT(!mPetrels.contains(CORMORANT));

   123       MOZ_RELEASE_ASSERT(seen.size() == 5);

   124       MOZ_RELEASE_ASSERT(seen.contains(GADFLY_PETREL));

   125       MOZ_RELEASE_ASSERT(seen.contains(TRUE_PETREL));

   126       MOZ_RELEASE_ASSERT(seen.contains(DIVING_PETREL));

   127       MOZ_RELEASE_ASSERT(seen.contains(STORM_PETREL));

   128       MOZ_RELEASE_ASSERT(seen.contains(CORMORANT));

   129     }

   130 

   131     void testAddAll() {

   132       EnumSet<SeaBird> procellariidae;

   133       procellariidae += mPetrelProcellariidae;

   134       procellariidae += mNonPetrelProcellariidae;

   135       MOZ_RELEASE_ASSERT(procellariidae.size() == 5);

   136 

   137       // Both procellariidae and mPetrels include GADFLY_PERTEL and TRUE_PETREL

   138       EnumSet<SeaBird> procellariiformes;

   139       procellariiformes += mDiomedeidae;

   140       procellariiformes += procellariidae;

   141       procellariiformes += mPetrels;

   142       MOZ_RELEASE_ASSERT(procellariiformes.size() == 8);

   143     }

   144 

   145     void testUnion() {

   146       EnumSet<SeaBird> procellariidae = mPetrelProcellariidae +

   147                                         mNonPetrelProcellariidae;

   148       MOZ_RELEASE_ASSERT(procellariidae.size() == 5);

   149 

   150       // Both procellariidae and mPetrels include GADFLY_PETREL and TRUE_PETREL

   151       EnumSet<SeaBird> procellariiformes = mDiomedeidae + procellariidae +

   152                                            mPetrels;

   153       MOZ_RELEASE_ASSERT(procellariiformes.size() == 8);

   154     }

   155 

   156     void testRemoveFrom() {

   157       EnumSet<SeaBird> likes = mPetrels;

   158       likes -= TRUE_PETREL;

   159       likes -= DIVING_PETREL;

   160       MOZ_RELEASE_ASSERT(likes.size() == 2);

   161       MOZ_RELEASE_ASSERT(likes.contains(GADFLY_PETREL));

   162       MOZ_RELEASE_ASSERT(likes.contains(STORM_PETREL));

   163     }

   164 

   165     void testRemove() {

   166       EnumSet<SeaBird> likes = mPetrels - TRUE_PETREL -

   167                                DIVING_PETREL;

   168       MOZ_RELEASE_ASSERT(likes.size() == 2);

   169       MOZ_RELEASE_ASSERT(likes.contains(GADFLY_PETREL));

   170       MOZ_RELEASE_ASSERT(likes.contains(STORM_PETREL));

   171     }

   172 

   173     void testRemoveAllFrom() {

   174       EnumSet<SeaBird> likes = mPetrels;

   175       likes -= mPetrelProcellariidae;

   176       MOZ_RELEASE_ASSERT(likes.size() == 2);

   177       MOZ_RELEASE_ASSERT(likes.contains(DIVING_PETREL));

   178       MOZ_RELEASE_ASSERT(likes.contains(STORM_PETREL));

   179     }

   180 

   181     void testRemoveAll() {

   182       EnumSet<SeaBird> likes = mPetrels - mPetrelProcellariidae;

   183       MOZ_RELEASE_ASSERT(likes.size() == 2);

   184       MOZ_RELEASE_ASSERT(likes.contains(DIVING_PETREL));

   185       MOZ_RELEASE_ASSERT(likes.contains(STORM_PETREL));

   186     }

   187 

   188     void testIntersect() {

   189       EnumSet<SeaBird> likes = mPetrels;

   190       likes &= mPetrelProcellariidae;

   191       MOZ_RELEASE_ASSERT(likes.size() == 2);

   192       MOZ_RELEASE_ASSERT(likes.contains(GADFLY_PETREL));

   193       MOZ_RELEASE_ASSERT(likes.contains(TRUE_PETREL));

   194     }

   195 

   196     void testInsersection() {

   197       EnumSet<SeaBird> likes = mPetrels & mPetrelProcellariidae;

   198       MOZ_RELEASE_ASSERT(likes.size() == 2);

   199       MOZ_RELEASE_ASSERT(likes.contains(GADFLY_PETREL));

   200       MOZ_RELEASE_ASSERT(likes.contains(TRUE_PETREL));

   201     }

   202 

   203     void testEquality() {

   204       EnumSet<SeaBird> likes = mPetrels & mPetrelProcellariidae;

   205       MOZ_RELEASE_ASSERT(likes == EnumSet<SeaBird>(GADFLY_PETREL,

   206                                            TRUE_PETREL));

   207     }

   208 

   209     void testDuplicates() {

   210       EnumSet<SeaBird> likes = mPetrels;

   211       likes += GADFLY_PETREL;

   212       likes += TRUE_PETREL;

   213       likes += DIVING_PETREL;

   214       likes += STORM_PETREL;

   215       MOZ_RELEASE_ASSERT(likes.size() == 4);

   216       MOZ_RELEASE_ASSERT(likes == mPetrels);

   217     }

   218 

   219 

   220     EnumSet<SeaBird> mAlcidae;

   221     EnumSet<SeaBird> mDiomedeidae;

   222     EnumSet<SeaBird> mPetrelProcellariidae;

   223     EnumSet<SeaBird> mNonPetrelProcellariidae;

   224     EnumSet<SeaBird> mPetrels;

   225 };

   226 

   227 int main()

   228 {

   229   EnumSetSuite suite;

   230   suite.runTests();

   231   return 0;

   232 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial