Java Code Examples for java.util.ArrayList#clear()

public void testTwoIterDiffKey() throws Exception {
  HdfsSortedOplogOrganizer organizer = new HdfsSortedOplogOrganizer(regionManager, 0);
  
  ArrayList<TestEvent> items = new ArrayList<TestEvent>();
  items.add(new TestEvent(("0"), ("V1")));
  organizer.flush(items.iterator(), items.size());
  items.clear();
  items.add(new TestEvent(("1"), ("V1")));
  organizer.flush(items.iterator(), items.size());
  
  List<TrackedReference<Hoplog>> oplogs = organizer.getSortedOplogs();
  HoplogSetIterator iter = new HoplogSetIterator(oplogs);
  assertTrue(iter.hasNext());
  int count = 0;
  for (ByteBuffer keyBB = null; iter.hasNext();) {
    keyBB = iter.next();
    byte[] key = HFileSortedOplog.byteBufferToArray(keyBB);
    byte[] value = HFileSortedOplog.byteBufferToArray(iter.getValue());
    assertEquals(String.valueOf(count), BlobHelper.deserializeBlob(key));
    assertEquals("V1", ((PersistedEventImpl) SortedHoplogPersistedEvent.fromBytes(value)).getValue());
    count++;
  }
  assertEquals(2, count);
  organizer.close();
}
 

private synchronized List<String> getDistinctValsFromCVAndPlan( String planName, String planColName, String cropColName ) {
    ArrayList<String> l = new ArrayList<String>();
    Set set = new HashSet();
    
    if ( planName != null )
        l.addAll( HSQLQuerier.getDistinctValuesForColumn( p.getConnection(),
                                                          planName,
                                                          planColName ) );

    l.addAll( HSQLQuerier.getDistinctValuesForColumn( p.getConnection(),
                                                      CROP_VAR_TABLE,
                                                      cropColName ) );

    // list now contains all values, possibly some duplicates
    // this ensures that the values are unique
    set.addAll ( l  );
    l.clear();
    l.addAll( set );
   
    return l;
    
}
 

@Override
boolean apply(IXulDataSelectContext dataCtx, ArrayList<XulDataNode> ctx) {
	ctx.clear();
	XulBinding binding = dataCtx.getBindingById(_dataSource);
	if (binding == null) {
		return true;
	}
	if (!binding.isDataReady() && !binding.isUpdated()) {
		return false;
	}
	XulDataNode dataNode = binding.getData();
	if (dataNode != null) {
		ctx.add(dataNode);
	}
	return true;
}
 

@Test
public void testGetNextTupleMultipleProjections() throws IOException, ExecException {
    t = tRandom;
    proj.attachInput(t);
    proj.setOverloaded(true);
    int j = 0;
    ArrayList<Integer> cols = new ArrayList<Integer>();

    while (true) {
        cols.add(j);
        cols.add(j + 1);
        proj.setColumns(cols);
        res = proj.getNextTuple();
        if (res.returnStatus == POStatus.STATUS_EOP)
            break;
        TupleFactory tupleFactory = TupleFactory.getInstance();
        ArrayList<Object> objList = new ArrayList<Object>();
        objList.add(t.get(j));
        objList.add(t.get(j + 1));
        Tuple expectedResult = tupleFactory.newTuple(objList);
        assertEquals(POStatus.STATUS_OK, res.returnStatus);
        assertEquals(expectedResult, res.result);
        ++j;
        cols.clear();
    }

    proj.attachInput(t);
    proj.setColumn(8);
    proj.setOverloaded(false);
    res = proj.getNextTuple();
    assertEquals(POStatus.STATUS_OK, res.returnStatus);
    assertEquals(t.get(8), res.result);
}
 

private void initDirWithJavaFiles(File libDir) throws IOException {

        if (libDir.exists()) {
            recursiveDelete(libDir);
        }
        libDir.mkdirs();
        ArrayList<String> scratchpad = new ArrayList<>();
        scratchpad.add("package lib;");
        scratchpad.add("public class Fbo {");
        scratchpad.add("public static void main(String... args){Foo.f();}");
        scratchpad.add("public static void f(){}");
        scratchpad.add("}");
        createFile(new File(libDir, "Fbo.java"), scratchpad);

        scratchpad.clear();
        scratchpad.add("package lib;");
        scratchpad.add("public class Foo {");
        scratchpad.add("public static void main(String... args){");
        scratchpad.add("for (String x : args) {");
        scratchpad.add("System.out.println(x);");
        scratchpad.add("}");
        scratchpad.add("Fbo.f();");
        scratchpad.add("}");
        scratchpad.add("public static void f(){}");
        scratchpad.add("}");
        createFile(new File(libDir, "Foo.java"), scratchpad);
    }
 

public Collisions project(Item item, float x, float y, float w, float h, float goalX, float goalY, CollisionFilter filter, Collisions collisions) {
  collisions.clear();
  ArrayList<Item> visited = project_visited;
  visited.clear();
  if (item != null) {
    visited.add(item);
  }
  float tl = min(goalX, x);
  float tt = min(goalY, y);
  float tr = max(goalX + w, x + w);
  float tb = max(goalY + h, y + h);

  float tw = tr - tl;
  float th = tb - tt;

  grid.grid_toCellRect(cellSize, tl, tt, tw, th, project_c);
  float cl = project_c.x, ct = project_c.y, cw = project_c.w, ch = project_c.h;
  HashMap<Item, Boolean> dictItemsInCellRect = getDictItemsInCellRect(cl, ct, cw, ch, project_dictItemsInCellRect);
  for (Item other : dictItemsInCellRect.keySet()) {
    if (!visited.contains(other)) {
      visited.add(other);
      Response response = filter.filter(item, other);
      if (response != null) {
        Rect o = getRect(other);
        float ox = o.x, oy = o.y, ow = o.w, oh = o.h;
        Collision col = rectHelper.rect_detectCollision(x, y, w, h, ox, oy, ow, oh, goalX, goalY);

        if (col != null) {
          collisions.add(col.overlaps, col.ti, col.move.x, col.move.y, col.normal.x, col.normal.y, col.touch.x, col.touch.y, col.itemRect.x, col.itemRect.y, col.itemRect.w, col.itemRect.h, col.otherRect.x, col.otherRect.y, col.otherRect.w, col.otherRect.h, item, other, response);
        }
      }
    }
  }
  if (tileMode) {
    collisions.sort();
  }
  return collisions;
}
 

private static ArrayList<Integer> palette(Palette p, int defaultColor) {

        ArrayList<Integer> extractedPalette = new ArrayList<>();

        //get all palettes
        Integer lightVibrant, vibrant, darkVibrant, lightMuted, muted, darkMuted;

        lightVibrant = p.getVibrantColor(defaultColor);
        vibrant = p.getVibrantColor(defaultColor);
        darkVibrant = p.getDarkVibrantColor(defaultColor);
        lightMuted = p.getLightMutedColor(defaultColor);
        muted = p.getMutedColor(defaultColor);
        darkMuted = p.getDarkMutedColor(defaultColor);

        extractedPalette.add(lightVibrant);
        extractedPalette.add(vibrant);
        extractedPalette.add(darkVibrant);
        extractedPalette.add(lightMuted);
        extractedPalette.add(muted);
        extractedPalette.add(darkMuted);

        //add also default color, because if the next method fails we have a color anyway
        extractedPalette.add(defaultColor);

        //pass these palettes to a hashset to avoid duplicates
        HashSet<Integer> hashSet = new HashSet<>();
        hashSet.addAll(extractedPalette);

        //add back these values to the palettes array list
        extractedPalette.clear();
        extractedPalette.addAll(hashSet);

        return extractedPalette;
    }
 

public static ArrayList<String> listFiles(String path, Context c) {
    ArrayList<String> mDirContent = new ArrayList<>();
    boolean showhidden = Settings.showHiddenFiles();

    if (!mDirContent.isEmpty())
        mDirContent.clear();

    final File file = new File(path);

    if (file.exists() && file.canRead()) {
        String[] list = file.list();

        // add files/folder to ArrayList depending on hidden status
        for (String aList : list) {
            if (!showhidden) {
                if (aList.charAt(0) != '.')
                    mDirContent.add(path + "/" + aList);
            } else {
                mDirContent.add(path + "/" + aList);
            }
        }
    } else if (Settings.rootAccess()) {
        mDirContent = RootCommands.listFiles(file.getAbsolutePath(), showhidden);
    } else {
        Toast.makeText(c, c.getString(R.string.cantreadfolder), Toast.LENGTH_SHORT).show();
    }
    return mDirContent;
}
 

@Test
public void testSerializerLazyInitializeInParallel() throws Exception {
	final String name = "testSerializerLazyInitializeInParallel";
	// use PojoTypeInfo which will create a new serializer when createSerializer is invoked.
	final TestStateDescriptor<String> desc =
		new TestStateDescriptor<>(name, new PojoTypeInfo<>(String.class, new ArrayList<>()));
	final int threadNumber = 20;
	final ArrayList<CheckedThread> threads = new ArrayList<>(threadNumber);
	final ExecutionConfig executionConfig = new ExecutionConfig();
	final ConcurrentHashMap<Integer, TypeSerializer<String>> serializers = new ConcurrentHashMap<>();
	for (int i = 0; i < threadNumber; i++) {
		threads.add(new CheckedThread() {
			@Override
			public void go() {
				desc.initializeSerializerUnlessSet(executionConfig);
				TypeSerializer<String> serializer = desc.getOriginalSerializer();
				serializers.put(System.identityHashCode(serializer), serializer);
			}
		});
	}
	threads.forEach(Thread::start);
	for (CheckedThread t : threads) {
		t.sync();
	}
	assertEquals("Should use only one serializer but actually: " + serializers, 1, serializers.size());
	threads.clear();
}
 

@SuppressWarnings("unchecked")
public <E> ArrayList<E> arrayList(int minCapacity) {
    ArrayList<E> list = (ArrayList<E>) arrayList;
    if (list == null) {
        arrayList = new ArrayList<Object>(minCapacity);
        return (ArrayList<E>) arrayList;
    }
    list.clear();
    list.ensureCapacity(minCapacity);
    return list;
}
 

public void unstashAll(int index) {
    if (stashed == null) {
        return;
    }
    ArrayList<StashedMessage> stashedMessages = stashed.get(index);
    if (stashedMessages == null || stashedMessages.size() == 0) {
        return;
    }
    StashedMessage stashedMessage;
    for (int i = stashedMessages.size() - 1; i >= 0; i--) {
        stashedMessage = stashedMessages.get(i);
        self().sendFirst(stashedMessage.getMessage(), stashedMessage.getSender());
    }
    stashedMessages.clear();
}
 

private void evalInputs(final ArrayList<AbraBaseSite> inputs)
{
  final ArrayList<AbraBaseSite> outputs = new ArrayList<>();

  for (final AbraBaseSite input : inputs)
  {
    if (!(input instanceof AbraSiteKnot))
    {
      outputs.add(input);
      continue;
    }

    final AbraSiteKnot knot = (AbraSiteKnot) input;
    if (knot.block.index != AbraBlockSpecial.TYPE_CONCAT)
    {
      outputs.add(input);
      continue;
    }

    knot.references--;
    for (final AbraBaseSite knotInput : knot.inputs)
    {
      outputs.add(knotInput);
      knotInput.references++;
    }
  }

  inputs.clear();
  inputs.addAll(outputs);
}
 

/**
 * Test isPropertyReadOnly() & isPropertyVisible().
 * 
 * @throws SemanticException
 */

public void testIsPropertyReadOnlyAndIsPropertyVisible( )
		throws SemanticException
{
	ArrayList elements = new ArrayList( );

	// bookmark and toc are all invisible

	SimpleMasterPageHandle element = elemFactory
			.newSimpleMasterPage( "my page" );//$NON-NLS-1$
	LabelHandle element1 = elemFactory.newLabel( "label1" ); //$NON-NLS-1$
	element.addElement( element1, SimpleMasterPage.PAGE_HEADER_SLOT );

	elements.add( element1 );
	GroupElementHandle groupHandle = new SimpleGroupElementHandle(
			designHandle, elements );

	assertTrue( !groupHandle.getPropertyHandle( ReportItem.TOC_PROP )
			.isVisible( ) );
	assertTrue( !groupHandle.getPropertyHandle( ReportItem.BOOKMARK_PROP )
			.isVisible( ) );
	assertTrue( !groupHandle
			.getPropertyHandle( Style.PAGE_BREAK_AFTER_PROP ).isVisible( ) );
	assertTrue( !groupHandle.getPropertyHandle(
			Style.PAGE_BREAK_BEFORE_PROP ).isVisible( ) );

	assertTrue( groupHandle.getPropertyHandle( ReportItem.TOC_PROP )
			.isReadOnly( ) );
	assertTrue( groupHandle.getPropertyHandle( ReportItem.BOOKMARK_PROP )
			.isReadOnly( ) );
	assertTrue( groupHandle.getPropertyHandle( Style.PAGE_BREAK_AFTER_PROP )
			.isReadOnly( ) );
	assertTrue( groupHandle
			.getPropertyHandle( Style.PAGE_BREAK_BEFORE_PROP ).isReadOnly( ) );

	// drop is only visible for cells in group
	elements.clear( );
	TableHandle table = elemFactory.newTableItem( "table" );
	RowHandle row = elemFactory.newTableRow( );
	CellHandle cell = elemFactory.newCell( );
	row.addElement( cell, RowHandle.CONTENT_SLOT );
	elements.add( cell );
	groupHandle = new SimpleGroupElementHandle( designHandle, elements );

	assertTrue( !groupHandle.getPropertyHandle( CellHandle.DROP_PROP )
			.isVisible( ) );
	assertTrue( groupHandle.getPropertyHandle( CellHandle.DROP_PROP )
			.isReadOnly( ) );
}
 

/**
 * Performs a number of random card drawings for the remaining board cards and uses this to compute the winning
 * chance per bot. The chance per bot is computed as percentages multiplied with 10, for example 29.0% is stored as
 * 290 so that simple integer representation is used with precision high enough. The odds information is added to
 * the stored match history.
 */
private void updateBotOdds()
{
	// set the current deck status as the starting point for each random draw
	deck.setSavePoint();
	int[] winsPerBot = new int[numberOfBots];
	
	// perform the given number of random draws for table cards and count the winners
	for(int n = 0; n < ODDS_RUNS; n++)
	{
		Vector<Card> tempTableCards = (Vector<Card>) tableCards.clone();
		while(tempTableCards.size() < 5)
			tempTableCards.add(deck.nextCard());
		
		int[] botHandStrengths = computeHandStrengths(botHands, tempTableCards);			
		int maxStrength = -1;
		ArrayList<Integer> winnerIndex = new ArrayList<Integer>();
		for(int i = 0; i < numberOfBots; i++)
	    {
			if(isInvolvedInHand[i] && botHandStrengths[i] >= maxStrength)
			{
				if(botHandStrengths[i] > maxStrength)
				{
					winnerIndex.clear();
					maxStrength = botHandStrengths[i];
				}
				winnerIndex.add(i);
			}
		}
		
		// keep track of the number of wins per bot in this simulation
		for(int i = 0; i < winnerIndex.size(); i++)
			winsPerBot[winnerIndex.get(i)]++;
			
		// restore the deck to the current state
		deck.restoreToSavePoint();
		tempTableCards.clear();
		
		// if all cards are on table, one run is sufficient, so make the stopping condition true
		if(tableCards.size() == 5)
			n = ODDS_RUNS;
	}
	
	// compute the total sum of winnings and use this to calculate the winning percentages
	int sum = 0;
	for(int i = 0; i < numberOfBots; i++)
		if(isInvolvedInHand[i])
			sum += winsPerBot[i];
			
	// output the odds of the involved players
	for(int i = 0; i < numberOfBots; i++)
	{
		String percentage;
		if(isInvolvedInHand[i])
		{
			int percTimesTen = (int) Math.round(1000*winsPerBot[i] / (sum + .0));
			percentage = Integer.toString(percTimesTen);
			// below 1%, add the zero that comes in font of the dot
			if(percTimesTen < 10)
				percentage = "0" + percentage;
			
			int stringLength = percentage.length();
			percentage = percentage.substring(0, stringLength - 1) + "." + percentage.substring(stringLength - 1);
		} else {
			percentage = "0.0";
		}
		handHistory += String.format("\n%s odds %s%%", players.get(i).getName(), percentage);
	}
}
 

/**
 * Copy data to CSV.
 *
 * @param csv CSVWriter.
 * @param rows Array of rows.
 * @param columns List of columns.
 * @param includeHeader True to include column headers in the copy.
 */
private void toCSV(final SmartCSVWriter csv, final int[] rows, final List<Integer> columns, final boolean includeHeader) throws IOException {
    int auditCounter = 0;
    final TableModel dataModel = table.getModel();
    int columnModelIdx;
    final ArrayList<String> data = new ArrayList<>();

    // Add column names.
    if (includeHeader) {
        final GraphTableModel gtmodel = (GraphTableModel) dataModel;
        final GraphElementType elementType = gtmodel.getElementType();

        for (final int column : columns) {
            columnModelIdx = table.convertColumnIndexToModel(column);
            String colName = dataModel.getColumnName(columnModelIdx);

            // If this is a transaction table, prefix the column name with the element type so we know which column is which.
            if (elementType == GraphElementType.TRANSACTION) {
                switch (gtmodel.getAttributeSegment(columnModelIdx).segment) {
                    case TX:
                        colName = GraphRecordStoreUtilities.TRANSACTION + colName;
                        break;
                    case VX_SRC:
                        colName = GraphRecordStoreUtilities.SOURCE + colName;
                        break;
                    case VX_DST:
                        colName = GraphRecordStoreUtilities.DESTINATION + colName;
                        break;
                    default:
                        break;
                }
            }

            data.add(colName);
        }

        csv.writeNext(data.toArray(new String[data.size()]));
    }

    // Add data.
    for (final int row : rows) {
        data.clear();
        for (final Integer j : columns) {
            final int rowModelIndex = table.convertRowIndexToModel(row);
            columnModelIdx = table.convertColumnIndexToModel(j);
            final Object o = dataModel.getValueAt(rowModelIndex, columnModelIdx);
            final String s = o == null ? null : o.toString();
            data.add(s);
            auditCounter++;
        }

        csv.writeNext(data.toArray(new String[data.size()]));
    }

    final int count = auditCounter;

    PluginExecution.withPlugin(new SimplePlugin("Copy To Clipboard") {
        @Override
        protected void execute(final PluginGraphs graphs, final PluginInteraction interaction, final PluginParameters parameters) throws InterruptedException, PluginException {
            ConstellationLoggerHelper.copyPropertyBuilder(this, count, ConstellationLoggerHelper.SUCCESS);
        }
    }).executeLater(null);
}
 

@Test
public void testRoleMembership() {
	Role role = roleService.getRole( role2Id );
	assertNotNull( "r2 must exist", role );
	ArrayList<String> roleList = new ArrayList<String>( 1 );
	roleList.add( role2Id );
	
	Collection<String> memberPrincipalIds = roleService.getRoleMemberPrincipalIds(role2NamespaceCode, role2Name,  Collections.<String, String>emptyMap());
	assertNotNull(memberPrincipalIds);
	assertEquals("RoleTwo should have 6 principal ids", 5, memberPrincipalIds.size());
	assertTrue( "p3 must belong to role", memberPrincipalIds.contains(principal3Id) );
	assertTrue( "p2 must belong to role (assigned via group)", memberPrincipalIds.contains(principal2Id) );
	assertTrue( "p1 must belong to r2 (via r1)", memberPrincipalIds.contains(principal1Id) );
	
	Collection<RoleMembership> members = roleService.getRoleMembers( roleList, Collections.<String, String>emptyMap() );
	assertNotNull( "returned list may not be null", members );
	assertFalse( "list must not be empty", members.isEmpty() );
	assertEquals("Returned list must have 4 members.", 4, members.size());
	boolean foundP3 = false;
	boolean foundG1 = false;
	boolean foundR1 = false;
	for (RoleMembership member : members) {
		if (member.getMemberId().equals(principal3Id) && member.getType().equals(MemberType.PRINCIPAL)) {
			foundP3 = true;
		} else if (member.getMemberId().equals(group1Id) && member.getType().equals(MemberType.GROUP)) {
			foundG1 = true;
		} else if (member.getMemberId().equals(principal1Id) && member.getType().equals(MemberType.PRINCIPAL)) {
			foundR1 = true;
			assertEquals("Should have r1 embedded role id.", role1Id, member.getEmbeddedRoleId());
		}
	}
	assertTrue("Failed to find p3 principal member", foundP3);
	assertTrue("Failed to find g1 group member", foundG1);
	assertTrue("Failed to find r1 role member", foundR1);
	
	role = roleService.getRole( role1Id );
	assertNotNull( "r1 must exist", role );
	roleList.clear();
	roleList.add( role1Id );
	members = roleService.getRoleMembers( roleList,  Collections.<String, String>emptyMap() );
	assertNotNull( "returned list may not be null", members );
	assertEquals("Should have 2 members", 2, members.size());
	Iterator<RoleMembership> iter = members.iterator();
	assertTrue("One of those members should be p1.", principal1Id.equals(iter.next().getMemberId()) || principal1Id.equals(iter.next().getMemberId()));
}
 

@Test
public void testWithOutCond1() throws Exception {
	String userName = "test-001";
	User user = prepareUser(userName);
	user.setYuanbao(100);
	user.setGoldenSimple(0);

	ArrayList<XinqiMessage> list = new ArrayList<XinqiMessage>();
	IoSession session = TestUtil.createIoSession(list);
	user.setSession(session);
	user.set_id(new UserId(username));
	user.setSessionKey(SessionKey.createSessionKeyFromRandomString());
	GameContext.getInstance().registerUserSession(session, user, null);
	
	TaskManager manager = TaskManager.getInstance();
	manager.deleteUserTasks(user);
	
	TaskPojo task = new TaskPojo();
	//2000 goledn
	task.setId("10000");
	task.setStep(1);
	task.setScript(ScriptHook.TASK_SELL_GOOD.getHook());
	task.setType(TaskType.TASK_ACHIVEMENT);
	task.setName("二道贩子");
	Award award = new Award();
	award.id = "-1";
	award.type = Constant.ACHIEVEMENT;
	task.addAward(award);
	LinkedList<TaskPojo> tasks = new LinkedList<TaskPojo>();
	tasks.add(task);
	user.addTasks(tasks);
	TaskManager.getInstance().setTaskById(task);
	
	//Sell goods
	Bag bag = user.getBag();
	WeaponPojo weapon = EquipManager.getInstance().getWeaponById(equipId2);
	PropData propData = weapon.toPropData(30, WeaponColor.WHITE);
	bag.addOtherPropDatas(propData);
	Thread.sleep(200);
	list.clear();
	
	ShopManager shopManager = ShopManager.getInstance();
	shopManager.sellGoodToShop(user, 20);
	ConfirmManager.getInstance().receiveConfirmMessage(user, "shop.sell", 1);
	
	Thread.sleep(200);
	System.out.println(list);
	
	XinqiMessage xinqi = null;
	for ( XinqiMessage msg : list ) {
		if (msg.payload instanceof BseFinishAchievement) {
			xinqi = msg;
		}
	}
	assertNotNull("BseFinishAchievement", xinqi);
}
 

private static IEnumerable<Object[]> AppendedPrependedConcatAlternationsData() {
    final int EnumerableCount = 4; // How many enumerables to concat together per test case.

    IEnumerable<Integer> foundation = Linq.empty();
    ArrayList<Integer> expected = new ArrayList<>();
    IEnumerable<Integer> actual = foundation;

    ArgsList argsList = new ArgsList();

    // each bit in the last EnumerableCount bits of i represent whether we want to prepend/append a sequence for this iteration.
    // if it's set, we'll prepend. otherwise, we'll append.
    for (int i = 0; i < (1 << EnumerableCount); i++) {
        // each bit in last EnumerableCount bits of j is set if we want to ensure the nth enumerable
        // concat'd is an ICollection.
        // Note: It is important we run over the all-bits-set case, since currently
        // Concat is specialized for when all inputs are ICollection.
        for (int j = 0; j < (1 << EnumerableCount); j++) {
            for (int k = 0; k < EnumerableCount; k++) {// k is how much bits we shift by, and also the item that gets appended/prepended.
                IEnumerable<Integer> nextRange = Linq.range(k, 1);
                boolean prepend = ((i >> k) & 1) != 0;
                boolean forceCollection = ((j >> k) & 1) != 0;

                if (forceCollection) {
                    nextRange = nextRange.toArray();
                }

                actual = prepend ? nextRange.concat(actual) : actual.concat(nextRange);
                if (prepend) {
                    expected.add(0, k);
                } else {
                    expected.add(k);
                }
            }

            argsList.add(Linq.of(expected.toArray()), actual.toArray());

            actual = foundation;
            expected.clear();
        }
    }
    return argsList;
}
 

/**
 * if there is only one non-domination level (i.e., all solutions are non-dominated with each
 * other), we should delete a solution from the most crowded subregion
 */
public void deleteRankOne(S indiv, int location) {

  double indivFitness = fitnessFunction(indiv, lambda[location]);

  // find the most crowded subregion, if there are more than one, keep them in crowdList
  ArrayList<Integer> crowdList = new ArrayList<>();
  int crowdIdx;
  int nicheCount = countOnes(0);
  if (location == 0) {
    nicheCount++;
  }
  crowdList.add(0);
  for (int i = 1; i < populationSize; i++) {
    int curSize = countOnes(i);
    if (location == i) {
      curSize++;
    }
    if (curSize > nicheCount) {
      crowdList.clear();
      nicheCount = curSize;
      crowdList.add(i);
    } else if (curSize == nicheCount) {
      crowdList.add(i);
    }
  }
  // determine the index of the crowded subregion
  if (crowdList.size() == 1) {
    crowdIdx = crowdList.get(0);
  } else {
    int listLength = crowdList.size();
    crowdIdx = crowdList.get(0);
    double sumFitness = sumFitness(crowdIdx);
    if (crowdIdx == location) {
      sumFitness = sumFitness + indivFitness;
    }
    for (int i = 1; i < listLength; i++) {
      int curIdx = crowdList.get(i);
      double curFitness = sumFitness(curIdx);
      if (curIdx == location) {
        curFitness = curFitness + indivFitness;
      }
      if (curFitness > sumFitness) {
        crowdIdx = curIdx;
        sumFitness = curFitness;
      }
    }
  }

  switch (nicheCount) {
    case 0:
      System.out.println("Empty subregion!!!");
      break;
    case 1:
      // if every subregion only contains one solution, delete the worst from indiv's subregion
      int targetIdx;
      for (targetIdx = 0; targetIdx < populationSize; targetIdx++) {
        if (subregionIdx[location][targetIdx] == 1) {
          break;
        }
      }
      double prev_func = fitnessFunction(population.get(targetIdx), lambda[location]);
      if (indivFitness < prev_func) {
        replace(targetIdx, indiv);
      }
      break;
    default:
      if (location == crowdIdx) {  // if indiv's subregion is the most crowded one
        deleteCrowdIndiv_same(location, nicheCount, indivFitness, indiv);
      } else {
        int curNC = countOnes(location);
        int crowdNC = countOnes(crowdIdx);

        if (crowdNC > (curNC + 1)) {  // if the crowdIdx subregion is more crowded, delete one from this subregion
          deleteCrowdIndiv_diff(crowdIdx, location, crowdNC, indiv);
        } else if (crowdNC < (curNC + 1)) { // crowdNC == curNC, delete one from indiv's subregion
          deleteCrowdIndiv_same(location, curNC, indivFitness, indiv);
        } else { // crowdNC == (curNC + 1)
          if (curNC == 0) {
            deleteCrowdIndiv_diff(crowdIdx, location, crowdNC, indiv);
          } else {
            double rnd = randomGenerator.nextDouble();
            if (rnd < 0.5) {
              deleteCrowdIndiv_diff(crowdIdx, location, crowdNC, indiv);
            } else {
              deleteCrowdIndiv_same(location, curNC, indivFitness, indiv);
            }
          }
        }
      }
      break;
  }

}
 

public static void main(String[] args) throws Exception {

        int initialSize = 20480*1024;
        int maximumMapSize = 16*1024*1024;
        int maximumFileSize = 300000000;

        File file = File.createTempFile("exp", "tmp");
        file.deleteOnExit();
        RandomAccessFile f = new RandomAccessFile(file, "rw");
        f.setLength(initialSize);

        FileChannel fc = f.getChannel();

        ByteBuffer[] buffers = new ByteBuffer[128];

        System.out.format("map %d -> %d\n", 0, initialSize);
        buffers[0] = fc.map(FileChannel.MapMode.READ_WRITE, 0, initialSize);

        int currentBuffer = 0;
        int currentSize = initialSize;
        int currentPosition = 0;

        ArrayList<String> junk = new ArrayList<String>();

        while (currentPosition+currentSize < maximumFileSize) {
            int inc = Math.max(1000*1024, (currentPosition+currentSize)/8);

            int size = currentPosition+currentSize+inc;
            f.setLength(size);

            while (currentSize+inc > maximumMapSize) {
                if (currentSize < maximumMapSize) {
                    System.out.format("map %d -> %d\n", currentPosition,
                        (currentPosition + maximumMapSize));
                    buffers[currentBuffer] = fc.map(FileChannel.MapMode.READ_WRITE,
                        currentPosition, maximumMapSize);
                    fillBuffer(buffers[currentBuffer], currentSize);
                }
                currentPosition += maximumMapSize;
                inc = currentSize+inc-maximumMapSize;
                currentSize = 0;
                currentBuffer++;
                if (currentBuffer == buffers.length) {
                    ByteBuffer[] old = buffers;
                    buffers = new ByteBuffer[currentBuffer+currentBuffer/2];
                    System.arraycopy(old, 0, buffers, 0, currentBuffer);                                        }
            }
            currentSize += inc;
            if (currentSize > 0) {
                System.out.format("map %d -> %d\n", currentPosition,
                    (currentPosition + currentSize));
                buffers[currentBuffer] = fc.map(FileChannel.MapMode.READ_WRITE,
                     currentPosition, currentSize);
                fillBuffer(buffers[currentBuffer], currentSize-inc);
            }

            // busy loop needed to reproduce issue
            long t = System.currentTimeMillis();
            while (System.currentTimeMillis() < t+500) {
                junk.add(String.valueOf(t));
                if (junk.size() > 100000) junk.clear();
            }
        }

        fc.close();
        // cleanup the ref to mapped buffers so they can be GCed
        for (int i = 0; i < buffers.length; i++)
            buffers[i] = null;
        System.gc();
        // Take a nap to wait for the Cleaner to cleanup those unrefed maps
        Thread.sleep(1000);
        System.out.println("TEST PASSED");
    }