Code example for SecureRandom

Methods: nextBytes, setSeed

0
 
              // non-initialized object 
 
              case 0 : // testing setSeed(..) 
                       ref.setSeed(zero); 
                       tst.setSeed(zero); 
                       testingSame(ref, tst); 
                       break; 
 
              case 5 : // testing setSeed(..) 
                       ref.setSeed(seed); 
                       tst.setSeed(seed); 
                       testingSame(ref, tst); 
                       break; 
 
              case 10 : // testing nextBytes(..) 
                        ref.nextBytes(zero); 
                        tst.nextBytes(zero); 
                        testingNotSame(ref, tst); 
                        break; 
 
              case 15 : // testing nextBytes(..) 
                        ref.nextBytes(seed); 
                        tst.nextBytes(seed); 
                        testingNotSame(ref, tst); 
                        break; 
 
              // object initialized with setSeed(zero) 
 
              case 1 : // testing setSeed(..) 
                       ref.setSeed(zero); 
                       tst.setSeed(zero); 
                       testingSame(ref, tst); 
                       break; 
 
              case 6 : // testing setSeed(..) 
                       ref.setSeed(seed); 
                       tst.setSeed(seed); 
                       testingSame(ref, tst); 
                       break; 
 
              case 11 : // testing nextBytes(..) 
                        ref.nextBytes(zero); 
                        tst.nextBytes(zero); 
                        testingSame(ref, tst); 
                        break; 
 
              case 16 : // testing nextBytes(..) 
                        ref.nextBytes(seed); 
                        tst.nextBytes(seed); 
                        testingSame(ref, tst); 
                        break; 
 
              // object initialized with setSeed(seed) 
 
              case 2 : // testing setSeed(..) 
                       ref.setSeed(zero); 
                       tst.setSeed(zero); 
                       testingSame(ref, tst); 
                       break; 
 
              case 7 : // testing setSeed(..) 
                       ref.setSeed(seed); 
                       tst.setSeed(seed); 
                       testingSame(ref, tst); 
                       break; 
 
              case 12 : // testing nextBytes(..) 
                        ref.nextBytes(zero); 
                        tst.nextBytes(zero); 
                        testingSame(ref, tst); 
                        break; 
 
              case 17 : // testing nextBytes(..) 
                        ref.nextBytes(seed); 
                        tst.nextBytes(seed); 
                        testingSame(ref, tst); 
                        break; 
 
              // object initialized with nextBytes(zero) 
 
              case 3 : // testing setSeed(..) 
                       ref.setSeed(zero); 
                       tst.setSeed(zero); 
                       if ( flag == SELF ) { 
                           testingSame(ref, tst); 
                       } else { 
                           testingNotSame(ref, tst); 
                       } 
                       break; 
 
              case 8 : // testing setSeed(..) 
                       ref.setSeed(seed); 
                       tst.setSeed(seed); 
                       if ( flag == SELF ) { 
                           testingSame(ref, tst); 
                       } else { 
                           testingNotSame(ref, tst); 
                       } 
                       break; 
 
              case 13 : // testing nextBytes(..) 
                        ref.nextBytes(zero); 
                        tst.nextBytes(zero); 
                        if ( flag == SELF ) { 
                            testingSame(ref, tst); 
                        } else { 
                            testingNotSame(ref, tst); 
                        } 
                        break; 
 
              case 18 : // testing nextBytes(..) 
                        ref.nextBytes(seed); 
                        tst.nextBytes(seed); 
                        if ( flag == SELF ) { 
                            testingSame(ref, tst); 
                        } else { 
                            testingNotSame(ref, tst); 
                        } 
                        break; 
 
              // object initialized with nextBytes(seed) 
 
              case 4 : // testing setSeed(..) 
                       ref.setSeed(zero); 
                       tst.setSeed(zero); 
                       if ( flag == SELF ) { 
                           testingSame(ref, tst); 
                       } else { 
                           testingNotSame(ref, tst); 
                       } 
                       break; 
 
              case 9 : // testing setSeed(..) 
                       ref.setSeed(seed); 
                       tst.setSeed(seed); 
                       if ( flag == SELF ) { 
                       testingSame(ref, tst); 
                       } else { 
                           testingNotSame(ref, tst); 
                       } 
                       break; 
 
              case 14 : // testing nextBytes(..) 
                        ref.nextBytes(zero); 
                        tst.nextBytes(zero); 
                        if ( flag == SELF ) { 
                            testingSame(ref, tst); 
                        } else { 
                            testingNotSame(ref, tst); 
                        } 
                        break; 
 
               case 19 : // testing nextBytes(..) 
                         ref.nextBytes(seed); 
                         tst.nextBytes(seed); 
                         if ( flag == SELF ) { 
                             testingSame(ref, tst); 
                         } else { 
                             testingNotSame(ref, tst); 
                         } 
                         break; 
 
               default: fail("ATTENTION: default case is not expected to happen"); 
            }