Example #1
1
        public void handle(PeerMessage event) {
          PeerAddress oldFriend;
          PeerAddress sender = event.getMSPeerSource();
          PeerAddress newFriend = event.getNewFriend();

          // add the sender address to the list of friends
          if (!friends.contains(sender)) {
            if (friends.size() == viewSize) {
              oldFriend = friends.get(rand.nextInt(viewSize));
              friends.remove(oldFriend);
              fdUnregister(oldFriend);
              Snapshot.removeFriend(serverPeerAddress, oldFriend);
            }

            friends.addElement(sender);
            fdRegister(sender);
            Snapshot.addFriend(serverPeerAddress, sender);
          }

          // add the received new friend from the sender to the list of friends
          if (!friends.contains(newFriend) && !serverPeerAddress.equals(newFriend)) {
            if (friends.size() == viewSize) {
              oldFriend = friends.get(rand.nextInt(viewSize));
              friends.remove(oldFriend);
              fdUnregister(oldFriend);
              Snapshot.removeFriend(serverPeerAddress, oldFriend);
            }

            friends.addElement(newFriend);
            fdRegister(newFriend);
            Snapshot.addFriend(serverPeerAddress, newFriend);
          }
        }
Example #2
1
  @Test(expected = FileNotFoundException.class)
  public final void testNoSuchFile() throws Exception {
    QueryIdFactory.reset();
    SubQueryId schid = QueryIdFactory.newSubQueryId(QueryIdFactory.newQueryId());
    QueryUnitId qid1 = QueryIdFactory.newQueryUnitId(schid);
    QueryUnitId qid2 = QueryIdFactory.newQueryUnitId(schid);

    File qid1Dir = new File(TEST_DATA + "/" + qid1.toString() + "/out");
    qid1Dir.mkdirs();
    File qid2Dir = new File(TEST_DATA + "/" + qid2.toString() + "/out");
    qid2Dir.mkdirs();

    Random rnd = new Random();
    FileWriter writer = new FileWriter(qid1Dir + "/" + "testHttp");
    String watermark1 = "test_" + rnd.nextInt();
    writer.write(watermark1);
    writer.flush();
    writer.close();

    writer = new FileWriter(qid2Dir + "/" + "testHttp");
    String watermark2 = "test_" + rnd.nextInt();
    writer.write(watermark2);
    writer.flush();
    writer.close();

    InterDataRetriever ret = new InterDataRetriever();
    HttpDataServer server = new HttpDataServer(NetUtils.createSocketAddr("127.0.0.1:0"), ret);
    server.start();

    ret.register(qid1, qid1Dir.getPath());
    InetSocketAddress addr = server.getBindAddress();
    assertDataRetrival(qid1, addr.getPort(), watermark1);
    ret.unregister(qid1);
    assertDataRetrival(qid1, addr.getPort(), watermark1);
  }
Example #3
0
  public static void bang() throws LineUnavailableException, InterruptedException {
    AudioFormat af =
        new AudioFormat(
            SAMPLE_RATE, // sampleRate
            8, // sampleSizeInBits
            1, // channels
            true, // signed
            false); // bigEndian
    SourceDataLine sdl = AudioSystem.getSourceDataLine(af);
    sdl.open(af);
    sdl.start();

    byte[] buf = new byte[1];
    Random r = new Random();
    boolean silence = true;
    for (int i = 0; i < 8000; i++) {
      while (r.nextInt() % 10 != 0) {
        buf[0] =
            silence
                ? 0
                : (byte)
                    Math.abs(
                        r.nextInt()
                            % (int) (1. + 63. * (1. + Math.cos(((double) i) * Math.PI / 8000.))));
        i++;
        sdl.write(buf, 0, 1);
      }
      silence = !silence;
    }
    sdl.drain();
    sdl.stop();
    sdl.close();
  }
  public void testWebSocketServer() {

    try {
      // randomly select two clients from the collection.
      for (int i = 0; i <= 1000; i++) {
        NettyTestClient from = clients.get(random.nextInt(clients.size()));
        NettyTestClient to = clients.get(random.nextInt(clients.size()));

        // this needs to be here when testing max size or max connections.
        if (to.isClosed()) {
          continue;
        }

        SocketMessage msg = messages.get(random.nextInt(messages.size()));
        msg.setText("Hola!");
        msg.setFrom(from.getUuid());
        msg.setTo(to.getUuid());
        msg.setDate(new Date());
        String json = JSONUtils.toJson(msg);
        from.send(json);

        Thread.sleep(TestConfig.getInstance().getMessageDelay());
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 /** Gets a WorldGen appropriate for this biome. */
 @Override
 public WorldGenAbstractTree func_150567_a(Random par1Random) {
   if (par1Random.nextInt(3) == 0) return new WorldGenTreeAsh(16, 8, false);
   else if (par1Random.nextInt(2) == 0)
     return new WorldGenTrees(false, 5 + par1Random.nextInt(4), 0, 0, false);
   else return this.treeGenCache;
 }
Example #6
0
 @Override
 public void populate(Chunk chunk, Random random) {
   if (chunk.getY() != 4) {
     return;
   }
   final World world = chunk.getWorld();
   if (random.nextInt(WATER_ODD) == 0) {
     final int x = chunk.getBlockX(random);
     final int z = chunk.getBlockZ(random);
     final int y = random.nextInt(128);
     WATER_POND.setRandom(random);
     WATER_POND.randomize();
     if (WATER_POND.canPlaceObject(world, x, y, z)) {
       WATER_POND.placeObject(world, x, y, z);
     }
   }
   if (random.nextInt(LAVA_ODD) == 0) {
     final int x = chunk.getBlockX(random);
     final int z = chunk.getBlockZ(random);
     final int y = random.nextInt(120) + 8;
     if (y >= 63 && random.nextInt(LAVA_SURFACE_ODD) != 0) {
       return;
     }
     LAVA_POND.setRandom(random);
     LAVA_POND.randomize();
     if (LAVA_POND.canPlaceObject(world, x, y, z)) {
       LAVA_POND.placeObject(world, x, y, z);
     }
   }
 }
Example #7
0
  public static void main(String[] args) {
    List<Map<String, Integer>> list = new ArrayList<Map<String, Integer>>();
    for (int i = 24; i <= 28; i++) {
      Map<String, Integer> map = new HashMap<String, Integer>();
      map.put("day", i);
      map.put("havedata", 0);
      list.add(map);
    }
    Random r = new Random();
    for (int i = 1; i <= 31; i++) {
      Map<String, Integer> map = new HashMap<String, Integer>();
      map.put("day", i);
      map.put("havedata", 1);
      map.put("nowfee", 3216 + r.nextInt(1000000));
      map.put("oldfee", 3216 + r.nextInt(1000000));
      map.put("dau", 3216 + r.nextInt(1000000));
      map.put("dnu", 3216 + r.nextInt(1000000));
      list.add(map);
    }
    for (int i = 1; i <= 6; i++) {
      Map<String, Integer> map = new HashMap<String, Integer>();
      map.put("day", i);
      map.put("havedata", 0);
      list.add(map);
    }
    System.out.println(array2JsonString(list));

    String json =
        "{\"code\":0,\"info\":\"success\",\"data\":{\"systemMail\":{\"mailVer\":19,\"target\":0,\"condition\":0,\"value\":2,\"title\":\"???è?????é??\",\"content\":\"???è?????é?????è?????é??\",\"sendTime\":1402555848,\"award\":{\"awardId\":0,\"gold\":2,\"heart\":2,\"diamond\":333,\"items\":[12,123],\"itemsCount\":[1,2]}}},\"sys_time\":1402555848}";
    JSONObject obj = getObj(json);
    System.out.println(obj.getJSONObject("data").getJSONObject("systemMail").getInt("mailVer"));
    System.out.println(obj.getInt("code"));
  }
Example #8
0
  @Test
  public void testSerializeIndexed() throws Exception {
    idbm.wipeDatabase();
    Random r = new Random(1L);
    Set<TestThrift> tts = new HashSet<TestThrift>();
    for (int test = 0; test < 10000; test++) {
      TestThrift tt =
          new TestThrift(
              null,
              r.nextInt(),
              r.nextLong(),
              r.nextBoolean(),
              (byte) r.nextInt(),
              (short) r.nextInt(),
              r.nextDouble(),
              generateString(r, 16),
              "abc");
      tts.add(tt);
      idbm.create(tt);
      idbm.commit();
    }

    idbm.dump(TestThrift.class, new File("."));
    idbm.wipeDatabase();

    idbm.load(TestThrift.class, new File("."));
    for (TestThrift tt : tts) {
      TestThrift tt2 = idbm.get(TestThrift.class, tt.id);
      Assert.assertEquals(tt, tt2);
    }

    new File("TestThrift.zombiedb.bz2").delete();
  }
Example #9
0
  private static void sendSimpleEmails(String toUserName, int count)
      throws MessagingException, InterruptedException, IOException {

    Session session = Session.getInstance(getEmailProperties());

    Random random = new Random();
    int emailSize = emails.length;
    for (int i = 1; i <= count; i++) {
      Thread.sleep(10000);

      MimeMessage msg = new MimeMessage(session);

      InternetAddress from = new InternetAddress(emails[random.nextInt(emailSize)]);

      InternetAddress to = new InternetAddress(toUserName);

      msg.setFrom(from);
      msg.addRecipient(Message.RecipientType.TO, to);
      msg.setSentDate(new Date());

      SimpleMessage randomMessage =
          SimpleMessage.values()[random.nextInt(SimpleMessage.values().length)];
      msg.setSubject(randomMessage.name());
      msg.setText(randomMessage.getBody());
      Transport.send(msg);
    }
  }
Example #10
0
  public static Observation makeObservationFor(POMDPDomain d, GroundedAction a, POMDPState s) {
    ObjectInstance indexer = s.getObject(Names.OBJ_INDEXER);
    int index = indexer.getDiscValForAttribute(Names.ATTR_INDEX);

    if (index == iterations) {
      return d.getObservation(Names.OBS_COMPLETE);
    }

    ObjectInstance leftDoor = s.getObject(Names.OBJ_LEFT_DOOR);
    ObjectInstance rightDoor = s.getObject(Names.OBJ_RIGHT_DOOR);

    int leftDoorTiger = leftDoor.getDiscValForAttribute(Names.ATTR_TIGERNESS);
    java.util.Random random = new java.util.Random();

    if (a.action.getName().equals(Names.ACTION_LISTEN)) {

      Observation left =
          d.getObservation(Names.OBS_LEFT_DOOR + random.nextInt(observationsPerState));
      Observation right =
          d.getObservation(Names.OBS_RIGHT_DOOR + random.nextInt(observationsPerState));

      if (leftDoorTiger == 1) {
        return random.nextDouble() < 1 - noise ? left : right;
      } else {
        return random.nextDouble() < 1 - noise ? right : left;
      }
    } else {
      return d.getObservation(Names.OBS_NULL);
    }
  }
Example #11
0
 protected static Data generateData() {
   char[] name = new char[16];
   for (int i = 0; i < name.length; i++) {
     name[i] = CHARS.charAt(random.nextInt(CHARS.length()));
   }
   return new Data(random.nextInt(), random.nextLong(), new String(name));
 }
 private void trySpawnSticks(World world, BlockPos pos, Random random) {
   int x = pos.getX();
   int y = pos.getY();
   int z = pos.getZ();
   y++;
   if (!world.isAirBlock(new BlockPos(x, y, z))) {
     return;
   }
   y++;
   if (!BlockTools.isTopValidAndSolid(world, pos)) {
     return;
   }
   for (int i = 0; i < 15; i++) {
     if (!world.isAirBlock(new BlockPos(x, y, z))) {
       if (isLeafBlock(world.getBlockState(new BlockPos(x, y, z)).getBlock())) {
         world.setBlockState(
             pos.up(),
             ModBlocks.sticksBlock
                 .getDefaultState()
                 .withProperty(
                     GenericBlock.FACING_HORIZ, EnumFacing.getHorizontal(random.nextInt(4))),
             3);
         SticksTE sticksTE = (SticksTE) world.getTileEntity(pos.up());
         sticksTE.setSticks(random.nextInt(6) + 1);
       }
       return;
     }
     y++;
   }
 }
Example #13
0
  /*
   * @param i - accepts int i for person number
   * @return - new positions
   */
  public int[] getNewPosition(int i) {
    // logic to auto select for computer player:
    if (i != 0) {
      // while space is not selected, randomly select rooms and spaces.
      while (spaceSelected == false) {

        // generate random number
        Random generator = new Random();
        int room = generator.nextInt(10);

        // random select a room
        allRooms[room].doClick();

        // generate random space
        int space = generator.nextInt(524);

        // randomly select a space
        btn[space].doClick();
      }
    }

    // if (debugBoardPanel) { System.out.println("[526] boardPanel.getNewPosition(): Called.") ; }
    int[] newPositions = {newPositionColumn, newPositionRow};

    // if (debugBoardPanel) { System.out.println("[530] boardPanel.getNewPosition().newPositions: "
    // + newPositions[0] + ", " + newPositions[1]); }

    return newPositions;
  }
  public void setButtonDefs() {
    // Preconditions: words is initialized, preloaded is initialized.
    // Postconditions: definitions of words are added onto the radio buttons.
    // Sets the buttons to be set to random definitions from the preloaded list.
    // Making sure to not load the same definitions.
    Random rnd = new Random();
    HashMap duplicates = new HashMap(5);
    String[] defs = new String[4];

    // Mastery Factor: Implementing an ADT
    // Uses a Hash Map to check for duplicates amongst the options.

    duplicates.add(words[current].getDefinition());
    for (int i = 0; i < 4; i++) {
      String def = preload[rnd.nextInt(PRELOADEDWORDS)].getDefinition();
      while (duplicates.contains(def)) {
        def = preload[rnd.nextInt(PRELOADEDWORDS)].getDefinition();
      }
      duplicates.add(def);
      defs[i] = def;
    }
    aRadBtn.setText(defs[0]);
    bRadBtn.setText(defs[1]);
    cRadBtn.setText(defs[2]);
    dRadBtn.setText(defs[3]);
  }
Example #15
0
  private String makeOneLetterOptions(int n, String answer, String longOptions, String avoid) {

    String abc;
    if (longOptions == null || longOptions.length() == 0) {
      abc = "ABCDEFGHIJKLMNOPRSTUVYÆØÅ";
    } else abc = longOptions;

    int nOptions = n;
    if (nOptions > abc.length()) nOptions = abc.length();

    String options = "";
    int pos = random.nextInt(nOptions);
    for (int i = 0; i < nOptions; i++) {
      if (i == pos) {
        // input correct answer as option
        options += answer;
      } else {
        // find a random character different from correct answer
        while (true) {
          char a = abc.charAt(random.nextInt(abc.length()));
          if (a == answer.charAt(0)) continue;
          if (options.indexOf(a, 0) >= 0) continue;
          // new character found
          options += Character.toString(a);
          break;
        }
      }
      if (i != n) options += ",";
    }
    return options;
  }
Example #16
0
  // select n options from the string allOptionsStr
  // make sure it contains 'answer'
  private String selectTwoLetterOptions(int nOptions, String answer, String allOptionsStr) {

    String[] allOptions = allOptionsStr.split(",");

    int n = nOptions;
    if (n > allOptions.length) n = allOptions.length;

    int posAnswer = random.nextInt(n);

    ArrayList<String> options = new ArrayList<String>();
    for (int i = 0; i < n; i++) {
      if (i == posAnswer) {
        // input correct answer as option
        options.add(answer);
      } else {
        // find a random option different from correct answer
        while (true) {
          String candidate = allOptions[random.nextInt(allOptions.length)];
          if (candidate.equals(answer)) continue;
          if (options.contains(candidate)) continue;

          // new option found
          options.add(candidate);
          break;
        }
      }
    }

    return joinArray(options);
  }
 public void Checkplanets() {
   GreenfootImage star = new GreenfootImage("Images/star.png");
   starW = star.getWidth(); // = 10
   starH = star.getHeight(); // = 10
   if (!topleft) { // 3 random stars if planets are not in the top left
     for (int x = 0; x < 3; x++) {
       starX = rgen.nextInt(Q1X);
       starY = rgen.nextInt(Q1Y);
       getBackground().drawImage(star, starX, starY);
     }
   }
   if (!topright) {
     for (int x = 0; x < 3; x++) {
       starX = rgen.nextInt(Q2X - Q1X) + Q1X;
       starY = rgen.nextInt(Q2Y);
       getBackground().drawImage(star, starX, starY);
     }
   }
   if (!bottomleft) {
     for (int x = 0; x < 3; x++) {
       starX = rgen.nextInt(Q1X);
       starY = rgen.nextInt(Q2Y) + Q2Y;
       getBackground().drawImage(star, starX, starY);
     }
   }
   if (!bottomright) {
     for (int x = 0; x < 3; x++) {
       starX = rgen.nextInt(Q1X) + Q1X;
       starY = rgen.nextInt(Q2Y) + Q2Y;
       getBackground().drawImage(star, starX, starY);
     }
   }
 }
 /**
  * Determines if this number represents a special number. A Dozen, a Half-Dozen, a Six-Pack, One
  * Miiiiilion, etc.
  *
  * @param decimal
  * @return
  */
 private static String getSpecialLargeIntegerString(BigDecimal decimal) {
   String number = decimal.toPlainString();
   String returnVal = "" + number;
   switch (number) {
     case "144":
       switch (random.nextInt(2)) {
         case 0:
           returnVal = "One Gross (144)";
           break;
         case 1:
           returnVal = "144";
           break;
         default:
           break;
       }
       break;
     case "1000":
       switch (random.nextInt(2)) {
         case 0:
           returnVal = "One Thousand";
           break;
         case 1:
           returnVal = "144";
           break;
         default:
           break;
       }
       break;
     case "1000000":
       switch (random.nextInt(2)) {
         case 0:
           returnVal = "One Miiiiiiillion";
           break;
         case 1:
           returnVal = "144";
           break;
         default:
           break;
       }
       break;
     case "1000000000":
       switch (random.nextInt(2)) {
         case 0:
           returnVal = "One Biiiiiiillion";
           break;
         case 1:
           returnVal = "144";
           break;
         default:
           break;
       }
       break;
     default:
       // format it nicely
       DecimalFormat formatter = new DecimalFormat("#,###");
       returnVal = formatter.format(decimal);
       break;
   }
   return returnVal;
 }
Example #19
0
  @Override
  public List<BaseRequest> getBaseRequest() {
    int orderId = 1;
    List<BaseRequest> baseRequestList = new ArrayList<BaseRequest>();

    // MVCs
    Pos mvc1 = createPos(10, 0);
    Pos mvc2 = createPos(30, 0);
    Pos[] mvc = new Pos[2];
    mvc[0] = mvc1;
    mvc[1] = mvc2;
    ArrayList<Pos> loc = new ArrayList<Pos>();
    //		int[] xx = {0,20,40,60,80};
    int[] xx = {0, 20, 39};
    for (int i = 0; i < TASKS_NUM; i++) {
      //			loc.add(createPos(29*rnd.nextInt(1), 10 + rnd.nextInt(20)));
      loc.add(createPos(xx[rnd.nextInt(3)], 10 + rnd.nextInt(10)));

      List<LocPriority> productList = new ArrayList<LocPriority>();
      productList.add(new LocPriority(loc.get(i), 0.99));
      BaseRequest br = new BaseRequest(orderId++, new Mvc(mvc[i % 2], MvcType.INPUT), productList);
      baseRequestList.add(br);
    }

    return baseRequestList;
  }
Example #20
0
  private Path[] createFiles() throws IOException {
    int numberOfStreams = Math.max(2, rnd.nextInt(10));
    mergeFactor = Math.max(mergeFactor, numberOfStreams);
    LOG.info("No of streams : " + numberOfStreams);

    Path[] paths = new Path[numberOfStreams];
    for (int i = 0; i < numberOfStreams; i++) {
      paths[i] = new Path(baseDir, "ifile_" + i + ".out");
      FSDataOutputStream out = fs.create(paths[i]);
      // write data with RLE
      IFile.Writer writer = new IFile.Writer(conf, out, keyClass, valClass, null, null, null, true);
      Map<Writable, Writable> data = createData();

      for (Map.Entry<Writable, Writable> entry : data.entrySet()) {
        writer.append(entry.getKey(), entry.getValue());
        originalData.put(entry.getKey(), entry.getValue());
        if (rnd.nextInt() % 2 == 0) {
          for (int j = 0; j < rnd.nextInt(100); j++) {
            // add some duplicate keys
            writer.append(entry.getKey(), entry.getValue());
            originalData.put(entry.getKey(), entry.getValue());
          }
        }
      }
      LOG.info("Wrote " + data.size() + " in " + paths[i]);
      data.clear();
      writer.close();
      out.close();
    }
    return paths;
  }
  @Override
  public void generate(
      Random rand,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider) {
    chunkX = chunkX << 4;
    chunkZ = chunkZ << 4;
    final BiomeGenBase biome = world.getBiomeGenForCoords(chunkX, chunkZ);

    if (BiomeSettings.GREENSWAMP.getBiome().isPresent()
            && biome == BiomeSettings.GREENSWAMP.getBiome().get()
        || BiomeSettings.MOUNTAINRIDGE.getBiome().isPresent()
            && biome == BiomeSettings.MOUNTAINRIDGE.getBiome().get()
        || BiomeSettings.REDWOODLUSH.getBiome().isPresent()
            && biome == BiomeSettings.REDWOODLUSH.getBiome().get()
        || BiomeSettings.WOODLANDS.getBiome().isPresent()
            && biome == BiomeSettings.WOODLANDS.getBiome().get())
      for (int i = 0; i < 2; i++) {
        final int x = chunkX + rand.nextInt(16) + 8;
        final int y = rand.nextInt(128);
        final int z = chunkZ + rand.nextInt(16) + 8;
        leafPileGen.generate(world, rand, x, y, z);
      }
  }
Example #22
0
  @StressTest
  @UiThreadTest
  public void testRandomTouch() {
    MemoryLogger memoryLogger = new MemoryLogger("testRandomTouch", 100);

    viewManager.setKeyboardLayout(KeyboardLayout.TWELVE_KEYS);

    final int actions = 500;

    final Random random = new Random();
    Rect rect = getViewRect();

    memoryLogger.logMemory("start");
    for (int i = 0; i < actions; i++) {
      final int x = rect.left + random.nextInt(rect.width());
      final int y = rect.top + random.nextInt(rect.height());

      inputView.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, x, y, 0));
      inputView.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_UP, x, y, 0));

      // updateRequest sends asynchronous message to server. So we need to wait a moment
      // for server processing.
      sleep(200);

      memoryLogger.logMemoryInterval();
    }
    memoryLogger.logMemory("start");
  }
 private void appendRandomChars(StringBuilder str, char[] chars, int minlen, int maxlen) {
   int len = rand.nextInt(maxlen - minlen) + minlen;
   int charsLen = chars.length;
   for (int i = 0; i < len; i++) {
     str.append(chars[rand.nextInt(charsLen)]);
   }
 }
  @Test
  public void testSoakTestWithRandomData() throws IOException, InterruptedException {

    // for (int i = 30; i < 50; i++) {
    System.out.print("SoakTesting ");
    int max = 1000000;
    for (int j = 1; j < max; j++) {
      if (j % 100 == 0) System.out.print(".");
      Random rnd = new Random(System.currentTimeMillis());

      final ChronicleMap<Integer, CharSequence> map = rnd.nextBoolean() ? map1 : map2;

      if (rnd.nextBoolean()) {
        map.put((int) rnd.nextInt(100), "test" + j);
      } else {
        map.remove((int) rnd.nextInt(100));
      }
    }

    System.out.println("\nwaiting till equal");

    waitTillUnchanged(1000);
    System.out.println("time t=" + t);
    Assert.assertEquals(new TreeMap(map1), new TreeMap(map2));
  }
 public void generateStructures(World world, Random rand, BlockPos position, int radius) {
   for (int i = 0; radius >= 0 && i < 3; ++i) {
     int j = radius + rand.nextInt(2);
     int k = (radius + rand.nextInt(2));
     int l = radius + rand.nextInt(2);
     float f = (float) (j + k + l) * 0.333F + 0.5F;
     for (BlockPos blockpos :
         BlockPos.getAllInBox(position.add(-j, -k, -l), position.add(j, k, l))) {
       if (blockpos.distanceSq(position) <= (double) (f * f)
           && world.isAirBlock(blockpos)
           && world
               .getBlockState(blockpos.down())
               .getBlock()
               .getUnlocalizedName()
               .contains("frozen")) {
         int chance = rand.nextInt(100);
         if (chance < 4) {
           int chance2 = rand.nextInt(20);
           System.out.println(chance2);
           switch (chance2) {
             default:
               generateGoldPile(world, rand, blockpos);
               break;
             case 1:
               generateArchNS(world, rand, blockpos);
               break;
             case 2:
               generateArchEW(world, rand, blockpos);
               break;
           }
         }
       }
     }
   }
 }
 private Object sample(Class<?> type) {
   if (type.isPrimitive()) {
     if (type == long.class) {
       return random.nextLong();
     }
     if (type == boolean.class) {
       return random.nextBoolean();
     }
   } else if (type.isEnum()) {
     Object[] candidates = type.getEnumConstants();
     return candidates[random.nextInt(candidates.length)];
   } else if (!type.isArray()) {
     if (type == String.class) {
       StringBuilder result = new StringBuilder();
       for (int len = 5 + random.nextInt(10); len > 0; len--) {
         result.append('a' + random.nextInt('z' - 'a'));
       }
       return result.toString();
     }
     if (type == Long.class) {
       return random.nextLong();
     }
     return mock(type);
   }
   throw new UnsupportedOperationException(
       "doesn't support " + type + " please add support for it.");
 }
Example #27
0
 private int getRandomColor() {
   Random randomGenerator = new Random();
   int red = randomGenerator.nextInt(255);
   int green = randomGenerator.nextInt(255);
   int blue = randomGenerator.nextInt(255);
   return Color.rgb(red, green, blue);
 }
  /**
   * The entry point to start the program.
   *
   * @param args parameters
   */
  public static void main(String[] args) {
    NameGenerator generator = new NameGenerator();

    // Load the source file
    String[] sourceArray = generator.loadFile("source");
    try (Writer writer =
        new BufferedWriter(
            new OutputStreamWriter(new FileOutputStream("generated.txt"), "utf-8"))) {

      // Randomly generate 100 names (including first name and last name)
      for (int i = 0; i < 100; i++) {
        // To generate two random number without duplication
        Random random = new Random();
        int first = random.nextInt(110) + 1;
        int second = -1;
        while (second == -1 || first == second) {
          second = random.nextInt(110) + 1;
        }

        // Write the name to the target file
        writer.write(sourceArray[first - 1] + " " + sourceArray[second - 1] + "\n");
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Example #29
0
 /*    */ public static String getName() /*    */ {
   /* 19 */ Random rnd = new Random();
   /* 20 */ String name =
       firstNames[rnd.nextInt(firstNameLength)] + secondNames[rnd.nextInt(secondNameLength)];
   /*    */
   /* 22 */ return name;
   /*    */ }
 public static BigInteger getRandomNumber(final int digCount, Random rnd) {
   final char[] ch = new char[digCount];
   for (int i = 0; i < digCount; i++) {
     ch[i] = (char) ('0' + (i == 0 ? rnd.nextInt(9) + 1 : rnd.nextInt(10)));
   }
   return new BigInteger(new String(ch));
 }