/** Returns all known role names. */
public List<String> listRoles() throws IOException {
ILockedRepository repo = null;
try {
repo = globalRepositoryManager.getProjectCentralRepository(REPOSITORY_NAME, false);
File workingDir = RepositoryUtil.getWorkingDir(repo.r());
FileFilter filter =
new FileFilter() {
@Override
public boolean accept(File file) {
return file.isFile() && file.getName().endsWith(ROLE_SUFFIX);
}
};
List<File> files = Lists.newArrayList(workingDir.listFiles(filter));
Function<File, String> function =
new Function<File, String>() {
@Override
public String apply(File file) {
return StringUtils.substringBeforeLast(file.getName(), ROLE_SUFFIX);
}
};
List<String> users = Lists.newArrayList(Lists.transform(files, function));
Collections.sort(users);
return users;
} finally {
Util.closeQuietly(repo);
}
}
class MockOutputMutator implements OutputMutator {
List<MaterializedField> removedFields = Lists.newArrayList();
List<ValueVector> addFields = Lists.newArrayList();
List<MaterializedField> getRemovedFields() {
return removedFields;
}
List<ValueVector> getAddFields() {
return addFields;
}
@Override
public void addFields(List<ValueVector> vv) {
return;
}
@Override
public <T extends ValueVector> T addField(MaterializedField field, Class<T> clazz)
throws SchemaChangeException {
return null;
}
@Override
public void allocate(int recordCount) {}
@Override
public boolean isNewSchema() {
return false;
}
}
public static void main(String[] args) throws Exception {
final Configuration configuration = HBaseConfiguration.create();
configuration.addResource("grade.xml");
String tables = configuration.get("hbase.cdn.tables");
if (Strings.isNullOrEmpty(tables)) {
return;
}
List<String> list = Lists.newArrayList(Splitter.on(",").split(tables));
List<String> results =
Lists.transform(
list,
new Function<String, String>() {
@Override
public String apply(@Nullable java.lang.String input) {
return String.format(
configuration.get("hdfs.directory.base.db"), new Date(), input);
}
});
String[] arrays =
new String[] {
Joiner.on(",").join(results),
String.format(configuration.get("hdfs.directory.num.middle"), new Date()),
String.format(configuration.get("hdfs.directory.num.result"), new Date())
};
AbstractJob job = new TopNJob();
// job.setStart(true);
int i = ToolRunner.run(configuration, job, arrays);
System.exit(i);
}
@Override
public void routeInputSourceTaskFailedEventToDestination(
int sourceTaskIndex, Map<Integer, List<Integer>> destinationTaskAndInputIndices) {
if (remainderRangeForLastShuffler < basePartitionRange) {
int startOffset = sourceTaskIndex * basePartitionRange;
List<Integer> allIndices = Lists.newArrayListWithCapacity(basePartitionRange);
for (int i = 0; i < basePartitionRange; ++i) {
allIndices.add(startOffset + i);
}
List<Integer> inputIndices = Collections.unmodifiableList(allIndices);
for (int i = 0; i < numDestinationTasks - 1; ++i) {
destinationTaskAndInputIndices.put(i, inputIndices);
}
startOffset = sourceTaskIndex * remainderRangeForLastShuffler;
allIndices = Lists.newArrayListWithCapacity(remainderRangeForLastShuffler);
for (int i = 0; i < remainderRangeForLastShuffler; ++i) {
allIndices.add(startOffset + i);
}
inputIndices = Collections.unmodifiableList(allIndices);
destinationTaskAndInputIndices.put(numDestinationTasks - 1, inputIndices);
} else {
// all tasks have same pattern
int startOffset = sourceTaskIndex * basePartitionRange;
List<Integer> allIndices = Lists.newArrayListWithCapacity(basePartitionRange);
for (int i = 0; i < basePartitionRange; ++i) {
allIndices.add(startOffset + i);
}
List<Integer> inputIndices = Collections.unmodifiableList(allIndices);
for (int i = 0; i < numDestinationTasks; ++i) {
destinationTaskAndInputIndices.put(i, inputIndices);
}
}
}
public static void unpath(World world, int i, int j, int k) {
List<ChunkCoordinates> blocks = Lists.newLinkedList();
List<ChunkCoordinates> notify = Lists.newLinkedList();
blocks.add(new ChunkCoordinates(i, j, k));
while (blocks.size() > 0) {
ChunkCoordinates coords = blocks.remove(0);
depolarize(world, coords.posX + 1, coords.posY, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY + 1, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY, coords.posZ + 1, blocks);
depolarize(world, coords.posX - 1, coords.posY, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY - 1, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY, coords.posZ - 1, blocks);
notify.add(coords);
}
for (ChunkCoordinates coords : notify) {
if (world.blockExists(coords.posX, coords.posY, coords.posZ)) {
world.markBlockForUpdate(coords.posX, coords.posY, coords.posZ);
world.notifyBlocksOfNeighborChange(
coords.posX,
coords.posY,
coords.posZ,
world.getBlock(coords.posX, coords.posY, coords.posZ));
}
}
}
@Override
public void readFields(DataInput in) throws IOException {
RowKeySchema schema = new RowKeySchema();
schema.readFields(in);
int maxLength = getTerminatorCount(schema);
int andLen = in.readInt();
List<List<KeyRange>> slots = Lists.newArrayListWithExpectedSize(andLen);
for (int i = 0; i < andLen; i++) {
int orlen = in.readInt();
List<KeyRange> orclause = Lists.newArrayListWithExpectedSize(orlen);
slots.add(orclause);
int maxSlotLength = 0;
for (int j = 0; j < orlen; j++) {
KeyRange range = new KeyRange();
range.readFields(in);
if (range.getLowerRange().length > maxSlotLength) {
maxSlotLength = range.getLowerRange().length;
}
if (range.getUpperRange().length > maxSlotLength) {
maxSlotLength = range.getUpperRange().length;
}
orclause.add(range);
}
maxLength += maxSlotLength;
}
this.init(slots, schema, maxLength);
}
@Test
public void runMultiValue() {
Tap source =
new MemorySourceTap(
Arrays.asList(
new Tuple(1, 1),
new Tuple(1, 2),
new Tuple(1, 1),
new Tuple((Integer) null, (Integer) 2)),
new Fields("key", "value"));
Pipe pipe = new Pipe("pipe");
pipe =
new IncrementForFieldValues(
pipe,
"Group",
"CounterA",
new Fields("key", "value"),
Lists.<Integer>newArrayList(1, 1));
pipe =
new IncrementForFieldValues(
pipe,
Counter.B,
new Fields("key", "value"),
Lists.<Object>newArrayList((Object) null, 2));
Flow f = CascadingUtil.get().getFlowConnector().connect(source, new NullTap(), pipe);
f.complete();
Assert.assertEquals(2l, Counters.get(f, "Group", "CounterA").longValue());
Assert.assertEquals(1l, Counters.get(f, Counter.B).longValue());
}
@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void queryMultiQueryableIndex(Blackhole blackhole) throws Exception {
List<QueryRunner<Result<TimeseriesResultValue>>> singleSegmentRunners = Lists.newArrayList();
QueryToolChest toolChest = factory.getToolchest();
for (int i = 0; i < numSegments; i++) {
String segmentName = "qIndex" + i;
QueryRunner<Result<TimeseriesResultValue>> runner =
QueryBenchmarkUtil.makeQueryRunner(
factory, segmentName, new QueryableIndexSegment(segmentName, qIndexes.get(i)));
singleSegmentRunners.add(toolChest.preMergeQueryDecoration(runner));
}
QueryRunner theRunner =
toolChest.postMergeQueryDecoration(
new FinalizeResultsQueryRunner<>(
toolChest.mergeResults(factory.mergeRunners(executorService, singleSegmentRunners)),
toolChest));
Sequence<Result<TimeseriesResultValue>> queryResult =
theRunner.run(query, Maps.<String, Object>newHashMap());
List<Result<TimeseriesResultValue>> results =
Sequences.toList(queryResult, Lists.<Result<TimeseriesResultValue>>newArrayList());
for (Result<TimeseriesResultValue> result : results) {
blackhole.consume(result);
}
}
@Test
public void testShowEditorsInReadOnlyMode() {
// Given:
userWorkspaceContext.setProjectActive(false);
userWorkspaceContext.setHasEditTranslationAccess(false);
selectedTU = currentPageRows.get(0);
ArrayList<ToggleEditor> currentEditors = Lists.newArrayList(editor);
when(editor.getId()).thenReturn(selectedTU.getId());
ArrayList<ToggleEditor> previousEditors = Lists.newArrayList(editor2);
presenter.setStatesForTesting(null, 0, display);
when(display.getId()).thenReturn(selectedTU.getId());
when(display.getEditors()).thenReturn(previousEditors, currentEditors);
when(sourceContentPresenter.getSourceContent(selectedTU.getId()))
.thenReturn(Optional.of("source"));
// When:
presenter.setSelected(selectedTU.getId());
// Then:
verify(editorTranslators).clearTranslatorList(previousEditors);
verify(editor).clearTranslatorList();
verify(display).showButtons(false);
verify(display).setToMode(ToggleEditor.ViewMode.VIEW);
verify(editorKeyShortcuts).enableNavigationContext();
}
@Test
public void testBuildJson() {
Employee emp =
new Employee("Amit", "Kapoor")
.setPhones(
Lists.newArrayList(new Phone("+1", 1234567890L), new Phone("+91", 9809901234L)));
Employee emp2 =
new Employee("Tim", "Johnes")
.setPhones(
Lists.newArrayList(new Phone("+1", 1234567890L), new Phone("+91", 9809901234L)));
String empJson =
new JSONSerializer()
.exclude("*.class", "fullName")
.serialize(Lists.newArrayList(emp, emp2));
System.out.println("JSON: \n" + empJson);
empJson =
new JSONSerializer()
.include("firstName", "lastName")
.exclude("*")
.serialize(Lists.newArrayList(emp, emp2));
System.out.println("JSON: \n" + empJson);
/*
Employee employee = new JSONDeserializer<Employee>().use(null, Employee.class).deserialize(empJson);
System.out.println("Deserialized EmpJson: \n" + employee);
*/
}
public SonarComponents(
FileLinesContextFactory fileLinesContextFactory,
ResourcePerspectives resourcePerspectives,
FileSystem fs,
JavaClasspath javaClasspath,
JavaTestClasspath javaTestClasspath,
CheckFactory checkFactory,
@Nullable CheckRegistrar[] checkRegistrars) {
this.fileLinesContextFactory = fileLinesContextFactory;
this.resourcePerspectives = resourcePerspectives;
this.fs = fs;
this.javaClasspath = javaClasspath;
this.javaTestClasspath = javaTestClasspath;
this.checkFactory = checkFactory;
checks = Lists.newArrayList();
if (checkRegistrars != null) {
CheckRegistrar.RegistrarContext registrarContext = new CheckRegistrar.RegistrarContext();
for (CheckRegistrar checkClassesRegister : checkRegistrars) {
checkClassesRegister.register(registrarContext);
registerCheckClasses(
registrarContext.repositoryKey(), Lists.newArrayList(registrarContext.checkClasses()));
}
}
}
private void removeTags(final String imageId) throws Exception {
final ImageInfo image = Images.lookupImage(imageId);
final String imageOwnerId = image.getOwnerUserId();
DeleteTagsTask task =
new DeleteTagsTask(
imageOwnerId,
Lists.newArrayList(image.getDisplayName()),
Lists.newArrayList(TAG_KEY_STATE, TAG_KEY_MESSAGE));
CheckedListenableFuture<Boolean> result = task.dispatch();
if (result.get()) {;
}
final List<VmInstance> instances = this.lookupInstances(imageId);
for (final VmInstance instance : instances) {
final String instanceId = instance.getInstanceId();
final String instanceOwnerId = instance.getOwnerUserId();
try {
task =
new DeleteTagsTask(
instanceOwnerId,
Lists.newArrayList(instanceId),
Lists.newArrayList(TAG_KEY_STATE, TAG_KEY_MESSAGE));
result = task.dispatch();
if (result.get()) {;
}
} catch (final Exception ex) {;
}
}
}
@Before
@SuppressWarnings("unchecked")
public void setUp() throws IOException {
String inputFile1 = tmpDir.copyResourceFileName("set1.txt");
String inputFile2 = tmpDir.copyResourceFileName("set2.txt");
if (pipelineClass == null) {
pipeline = MemPipeline.getInstance();
} else {
pipeline = new MRPipeline(pipelineClass, tmpDir.getDefaultConfiguration());
}
PCollection<String> firstCollection =
pipeline.read(At.textFile(inputFile1, typeFamily.strings()));
PCollection<String> secondCollection =
pipeline.read(At.textFile(inputFile2, typeFamily.strings()));
LOG.info(
"Test fixture: ["
+ pipeline.getClass().getSimpleName()
+ " : "
+ typeFamily.getClass().getSimpleName()
+ "] First: "
+ Lists.newArrayList(firstCollection.materialize().iterator())
+ ", Second: "
+ Lists.newArrayList(secondCollection.materialize().iterator()));
union = secondCollection.union(firstCollection);
}
private void transformAllAuthorities(
Function<RoleGrantedAuthority, RoleGrantedAuthority> function,
String commitMessage,
User currentUser)
throws IOException, GitAPIException {
ILockedRepository repo = null;
try {
List<String> users = listUsers();
users.add(ANONYMOUS_USER_LOGIN_NAME);
repo = globalRepositoryManager.getProjectCentralRepository(REPOSITORY_NAME, false);
boolean anyChanged = false;
for (String loginName : users) {
List<RoleGrantedAuthority> authorities = getUserAuthorities(loginName, repo);
List<RoleGrantedAuthority> newAuthorities =
Lists.newArrayList(Lists.transform(authorities, function));
if (!newAuthorities.equals(authorities)) {
saveUserAuthorities(loginName, Sets.newHashSet(newAuthorities), repo, currentUser, false);
anyChanged = true;
}
}
if (anyChanged) {
PersonIdent ident = new PersonIdent(currentUser.getLoginName(), currentUser.getEmail());
Git.wrap(repo.r())
.commit()
.setAuthor(ident)
.setCommitter(ident)
.setMessage(commitMessage)
.call();
}
} finally {
Util.closeQuietly(repo);
}
}
protected List<Vertex> getFilteredVertices() {
if (isAclEnabled()) {
// Get All nodes when called should filter with ACL
List<OnmsNode> onmsNodes = getNodeDao().findAll();
// Transform the onmsNodes list to a list of Ids
final List<Integer> nodes =
Lists.transform(
onmsNodes,
new Function<OnmsNode, Integer>() {
@Override
public Integer apply(OnmsNode node) {
return node.getId();
}
});
// Filter out the nodes that are not viewable by the user.
return Lists.newArrayList(
Collections2.filter(
m_vertexProvider.getVertices(),
new Predicate<Vertex>() {
@Override
public boolean apply(Vertex vertex) {
return nodes.contains(vertex.getNodeID());
}
}));
} else {
return m_vertexProvider.getVertices();
}
}
public static void trainModel(String filteredDataPath, String modelpath) throws IOException {
String line = "";
String combline = "";
// read and process raw data
BufferedReader br = new BufferedReader(new FileReader(filteredDataPath));
while ((line = br.readLine()) != null) combline = combline + " " + line;
List<String> words = Lists.newArrayList(combline.split(" "));
List<List<String>> localDoc = Lists.newArrayList(words, words);
// build a context object
JavaSparkContext sc = new JavaSparkContext("local", "Word2VecSuite");
JavaRDD<List<String>> doc = sc.parallelize(localDoc);
// training settings
Word2Vec word2vec = new Word2Vec().setVectorSize(100).setMinCount(50).setSeed(42L);
// train
Word2VecModel model = word2vec.fit(doc);
// save model
SparkContext sc1 = sc.toSparkContext(sc);
model.save(sc1, modelpath);
System.out.println("Model has been saved in folder: " + modelpath);
}
static {
ProductMatcher toothBrushProductMatcher = new SingleProductMatcher(toothBrush);
DiscountElement toothBrushFirstTwo = new DiscountElement(noDiscount, 2);
DiscountElement toothBrushFreeOne = new DiscountElement(freeDiscount, 1);
toothBrushPromotionElement = new PromotionElement();
toothBrushPromotionElement.setDiscountElements(
Lists.newArrayList(toothBrushFirstTwo, toothBrushFreeOne));
toothBrushPromotionElement.setMatcher(toothBrushProductMatcher);
toothBrushPromotionElement.setTotalRequired(3);
ProductMatcher chipsProductMatcher = new SingleProductMatcher(chips);
DiscountElement chipsDiscount = new DiscountElement(fixed200Discount, 1);
chipsPromotionElement = new PromotionElement();
chipsPromotionElement.setDiscountElements(Lists.newArrayList(chipsDiscount));
chipsPromotionElement.setMatcher(chipsProductMatcher);
chipsPromotionElement.setTotalRequired(1);
ProductMatcher salsaProductMatcher = new SingleProductMatcher(salsa);
DiscountElement salsaDiscount = new DiscountElement(fixed299Discount, 1);
salsaPromotionElement = new PromotionElement();
salsaPromotionElement.setDiscountElements(Lists.newArrayList(salsaDiscount));
salsaPromotionElement.setMatcher(salsaProductMatcher);
salsaPromotionElement.setTotalRequired(1);
}
@Test
public void testGetAllWithBinaryData() throws Exception {
Store<ByteArray, byte[], byte[]> store = getStore();
List<ByteArray> keys = Lists.newArrayList();
List<byte[]> values = Lists.newArrayList();
// The Byte 0x8c is interesting, because if you use GetContent method of
// MimeBodyPart it gets converted to 0xc2 and 0x8c
// This thread tracks this question
// http://stackoverflow.com/questions/23023583/mimebodypart-getcontent-corrupts-binary-data
byte[] interestingByte = new byte[] {(byte) 0x8c};
ByteArray interestingKey = new ByteArray(interestingByte);
keys.add(interestingKey);
values.add(interestingByte);
// Add all possible byte values
byte[] allPossibleBytes = getAllPossibleBytes();
ByteArray allPossibleKey = new ByteArray(allPossibleBytes);
keys.add(allPossibleKey);
values.add(allPossibleBytes);
assertEquals(keys.size(), values.size());
int count = keys.size();
for (int i = 0; i < count; i++) {
VectorClock vc = getClock(0, 0);
store.put(keys.get(i), new Versioned<byte[]>(values.get(i), vc), null);
}
Map<ByteArray, List<Versioned<byte[]>>> result = store.getAll(keys, null);
assertGetAllValues(keys, values, result);
}
private void checkPossiblesTimeboxes(
final Participant participant, List<TimeBox> possibleTbs, Priority priority) {
if (possibleTbs.size() == 1) {
boolean allocated = allocateTimeBox(possibleTbs.get(0), participant);
if (allocated) return;
}
if (!possibleTbs.isEmpty()) {
buffer.put(participant, Lists.newArrayList(possibleTbs));
System.out.println("insert " + possibleTbs.size() + " timeboxes in the buffer");
final Priority nextPriority = getNextPriority(priority);
if (nextPriority != null) {
System.out.println("set priority level to : " + nextPriority.getRole());
// filter the unavaibilities to get only the ones matching the current priority level
Collection<Unavailability> unavailabilities =
Collections2.filter(
this.unavailabilities,
new Predicate<Unavailability>() {
public boolean apply(Unavailability a) {
Person p = a.getPerson();
return (p.equals(participant.getStudent())
|| p.equals(participant.getFollowingTeacher()))
&& (p.getRole() == nextPriority.getRole());
}
});
System.out.println("unavailabilities found: " + unavailabilities.size());
System.out.println("{");
for (Unavailability ua : unavailabilities) {
System.out.println(ua.getPeriod().getFrom() + " - " + ua.getPeriod().getTo());
}
System.out.println("}");
if (!unavailabilities.isEmpty()) {
for (TimeBox timeBox : Lists.newArrayList(possibleTbs)) {
System.out.println(
"check unavailability "
+ (new DateTime(timeBox.getFrom()).toString("dd/MM/yyyy HH:mm")));
// Check if there is no unavailabilities for that timebox
if (!AlgoPlanningUtils.isAvailable(unavailabilities, timeBox)) {
System.out.println("removing one timebox...");
possibleTbs.remove(timeBox);
}
}
}
// let's do it again
checkPossiblesTimeboxes(participant, possibleTbs, nextPriority);
}
}
}
@Test
public void pullFileProjectUsingFileMapping() throws Exception {
PullOptionsImpl opts = mockServerRule.getPullOpts();
opts.setPullType("trans");
File pullBaseDir = tempFolder.newFolder("file-pull-test");
opts.setSrcDir(pullBaseDir);
opts.setTransDir(pullBaseDir);
log.debug("pull base dir is: {}", pullBaseDir);
// we define our own rule
opts.setFileMappingRules(
Lists.newArrayList(
new FileMappingRule("**/*.odt", "{extension}/{path}/{locale}/{filename}.{extension}"),
new FileMappingRule(
"**/*.ods", "{extension}/{locale_with_underscore}/{filename}.{extension}")));
InputStream sourceFileStream = IOUtils.toInputStream("source content", Charsets.UTF_8);
InputStream transFileStream = IOUtils.toInputStream("translation content", Charsets.UTF_8);
ArrayList<ResourceMeta> remoteDocList =
Lists.newArrayList(new ResourceMeta("test-ods.ods"), new ResourceMeta("test-odt.odt"));
RawPullCommand pullCommand =
mockServerRule.createRawPullCommand(remoteDocList, sourceFileStream, transFileStream);
pullCommand.run();
assertThat(new File(pullBaseDir, "odt/zh-CN/test-odt.odt").exists(), is(true));
assertThat(new File(pullBaseDir, "ods/zh_CN/test-ods.ods").exists(), is(true));
}
public void testActions() {
ActionDef def = Mockito.mock(ActionDef.class);
Action test = new MyAction(null, def, null);
List<Action> actions = test.getActions();
assertNotNull("Actions should never be null", actions);
assertEquals("Actions should empty", 0, actions.size());
List<Action> newActions = Lists.newArrayList(getActionWithId("a"), getActionWithId("b"));
test.add(newActions);
actions = test.getActions();
assertNotNull("Actions should never be null", actions);
assertEquals("Actions should be length 2", 2, actions.size());
assertEquals("Action 'a' should be first", "a", actions.get(0).getId());
assertEquals("Action 'b' should be first", "b", actions.get(1).getId());
newActions = Lists.newArrayList(getActionWithId("c"), getActionWithId("d"));
test.add(newActions);
actions = test.getActions();
assertNotNull("Actions should never be null", actions);
assertEquals("Actions should be length 4", 4, actions.size());
assertEquals("Action 'a' should be first", "a", actions.get(0).getId());
assertEquals("Action 'b' should be first", "b", actions.get(1).getId());
assertEquals("Action 'c' should be first", "c", actions.get(2).getId());
assertEquals("Action 'd' should be first", "d", actions.get(3).getId());
}
public List getStichSlots() {
ArrayList arraylist = Lists.newArrayList();
Iterator iterator = this.stitchSlots.iterator();
while (iterator.hasNext()) {
Stitcher.Slot slot = (Stitcher.Slot) iterator.next();
slot.getAllStitchSlots(arraylist);
}
ArrayList arraylist1 = Lists.newArrayList();
Iterator iterator1 = arraylist.iterator();
while (iterator1.hasNext()) {
Stitcher.Slot slot1 = (Stitcher.Slot) iterator1.next();
Stitcher.Holder holder = slot1.getStitchHolder();
TextureAtlasSprite textureatlassprite = holder.getAtlasSprite();
textureatlassprite.initSprite(
this.currentWidth,
this.currentHeight,
slot1.getOriginX(),
slot1.getOriginY(),
holder.isRotated());
arraylist1.add(textureatlassprite);
}
return arraylist1;
}
@Override
public void destroy() {
// perform removals in reverse order since latter logics often depend on former logics
for (IThingLogic logic : Lists.newArrayList(Lists.reverse(logics))) {
removeThingLogic(logic);
}
}
@Override
public Response<List<Integer>> ancestorsOf(Integer anyId) {
Response<List<Integer>> result = new Response<List<Integer>>();
if (anyId == null) {
log.error("id can not be null");
result.setError("params.not.null");
return result;
}
List<Address> addresses = Lists.newArrayListWithExpectedSize(3);
try {
Integer id = anyId;
while (id > 0) {
Address address = addressCache.getUnchecked(id);
addresses.add(address);
id = address.getParentId();
}
List<Integer> addressIds = Lists.newArrayListWithCapacity(MAX_ADDRESS_LEVEL);
for (Address address : addresses) {
addressIds.add(address.getId());
}
// 默认添加全国
addressIds.add(id);
result.setResult(addressIds);
return result;
} catch (Exception e) {
log.error(
"failed find ancestors of address(id={}), cause:{}",
anyId,
Throwables.getStackTraceAsString(e));
result.setError("ancestor.query.fail");
return result;
}
}
@Test
public final void shouldNotSaveFormBecauseOfDeviationCausesValidationErrors() {
// given
stubProgressType(ProgressType.PLANNED);
stubTechnologyOperation(null);
Entity deviationCauseEntity = mockEntity(dataDefinition);
Entity invalidDeviationCauseEntity = mockEntity(dataDefinition);
given(invalidDeviationCauseEntity.isValid()).willReturn(false);
given(dataDefinition.save(deviationCauseEntity)).willReturn(invalidDeviationCauseEntity);
AwesomeDynamicListComponent deviationCausesAdl = mock(AwesomeDynamicListComponent.class);
stubViewComponent(CORRECTION_CAUSE_TYPES_ADL_REF, deviationCausesAdl);
stubHasManyField(
ppsEntity,
ProductionPerShiftFields.PLANNED_PROGRESS_CORRECTION_TYPES,
Lists.newArrayList(deviationCauseEntity));
// when
progressPerShiftViewSaver.save(view);
// then
verify(txStatus, never()).setRollbackOnly();
verify(dataDefinition).save(deviationCauseEntity);
verify(dataDefinition, never()).save(ppsEntity);
verify(deviationCausesAdl).setFieldValue(Lists.newArrayList(invalidDeviationCauseEntity));
verify(form)
.addMessage("qcadooView.message.saveFailedMessage", ComponentState.MessageType.FAILURE);
}
/**
* Reads a tab-separated file and puts the contents into a map.
*
* <p>We give a few options: - You can set the index for the key to the map. If the key is not
* zero, we only add the first column as a value to this map (and so setting overwrite to true in
* this case doesn't make a whole lot of sense - just use readMapFromTsv instead). - If overwrite
* is true, we don't bother checking to see if the key is already in the map. This will speed up
* the processing if you know that your file only has one line per unique key. - You can provide a
* LineFilter object that wlil be called with each line to determine if it should be skipped.
*/
public Map<String, List<String>> readMapListFromTsvReader(
BufferedReader reader, int keyIndex, boolean overwrite, LineFilter filter)
throws IOException {
Map<String, List<String>> map = Maps.newHashMap();
String line;
while ((line = reader.readLine()) != null) {
String[] fields = line.split("\t");
if (filter != null && filter.filter(fields)) continue;
String key = fields[keyIndex];
List<String> list;
if (overwrite) {
list = Lists.newArrayList();
map.put(key, list);
} else {
list = map.get(key);
if (list == null) {
list = Lists.newArrayList();
map.put(key, list);
}
}
if (keyIndex == 0) {
for (int i = 1; i < fields.length; i++) {
list.add(fields[i]);
}
} else {
list.add(fields[0]);
}
}
return map;
}
@Test
public void analyseSingleArticleSourcesTest() {
Library library = createSimpleLibrary();
Article article = library.getArticles().get(0);
assertThat("name of article", article.getTitle(), is(equalTo("F**k the system")));
ISourceAnalysator analysator = createSourceAnalysator(library);
Map<GeneralSource, List<Source>> generalSources =
analysator.getGeneralSourcesOfArticle(article);
assertThat("general sopurces count", generalSources.size(), is(equalTo(2)));
List<GeneralSource> requiredSources = Lists.newArrayList(spiegel, guardian);
for (Entry<GeneralSource, List<Source>> entry : generalSources.entrySet()) {
GeneralSource generalSource = entry.getKey();
boolean removedGeneralSource = requiredSources.remove(generalSource);
assertThat("expected general source was found", removedGeneralSource, is(true));
List<Source> sources = entry.getValue();
if (generalSource.equals(spiegel)) {
assertThat(
"count of referenced articles of " + generalSource.getName(),
sources.size(),
is(equalTo(2)));
} else if (generalSource.equals(guardian)) {
assertThat(
"count of referenced articles of " + generalSource.getName(),
sources.size(),
is(equalTo(1)));
} else {
fail("wrong general source");
}
}
printSourcesOfArticles(Lists.newArrayList(article), generalSources);
}
@Override
public DataResponse<Iterable<TestResult>> search(TestResultRequest request) {
Component component = componentRepository.findOne(request.getComponentId());
if (!component.getCollectorItems().containsKey(CollectorType.Test)) {
return new DataResponse<>(null, 0L);
}
List<TestResult> result = new ArrayList<>();
for (CollectorItem item : component.getCollectorItems().get(CollectorType.Test)) {
QTestResult testResult = new QTestResult("testResult");
BooleanBuilder builder = new BooleanBuilder();
builder.and(testResult.collectorItemId.eq(item.getId()));
if (request.validStartDateRange()) {
builder.and(
testResult.startTime.between(request.getStartDateBegins(), request.getStartDateEnds()));
}
if (request.validEndDateRange()) {
builder.and(
testResult.endTime.between(request.getEndDateBegins(), request.getEndDateEnds()));
}
if (request.validDurationRange()) {
builder.and(
testResult.duration.between(
request.getDurationGreaterThan(), request.getDurationLessThan()));
}
if (!request.getTypes().isEmpty()) {
builder.and(testResult.testCapabilities.any().type.in(request.getTypes()));
}
if (request.getMax() == null) {
result.addAll(
Lists.newArrayList(
testResultRepository.findAll(builder.getValue(), testResult.timestamp.desc())));
} else {
PageRequest pageRequest =
new PageRequest(0, request.getMax(), Sort.Direction.DESC, "timestamp");
result.addAll(
Lists.newArrayList(
testResultRepository.findAll(builder.getValue(), pageRequest).getContent()));
}
}
// One collector per Type. get(0) is hardcoded.
if (!CollectionUtils.isEmpty(component.getCollectorItems().get(CollectorType.Test))
&& (component.getCollectorItems().get(CollectorType.Test).get(0) != null)) {
Collector collector =
collectorRepository.findOne(
component.getCollectorItems().get(CollectorType.Test).get(0).getCollectorId());
if (collector != null) {
return new DataResponse<>(
pruneToDepth(result, request.getDepth()), collector.getLastExecuted());
}
}
return new DataResponse<>(null, 0L);
}
@Test
public void substrLtrim() throws Exception {
List<Expression> ltrimArgs = Lists.newArrayList(getInvertedLiteral(" blah", PDataType.CHAR));
Expression ltrim = new LTrimFunction(ltrimArgs);
List<Expression> substrArgs = Lists.newArrayList(ltrim, getLiteral(3), getLiteral(2));
evaluateAndAssertResult(new SubstrFunction(substrArgs), "ah");
}
static Map<String, WorkflowMappingBean> asMappingBeans(WorkflowScheme scheme) {
if (scheme.getMappings().isEmpty()) {
return ImmutableMap.of();
}
Map<String, WorkflowMappingBean> mappings = Maps.newHashMap();
for (Map.Entry<String, String> mapping : scheme.getMappings().entrySet()) {
final String issueType = mapping.getKey();
final String workflowName = mapping.getValue();
WorkflowMappingBean mappingBean = mappings.get(workflowName);
if (mappingBean == null) {
mappingBean = new WorkflowMappingBean(workflowName, Lists.<String>newArrayList());
mappingBean.setDefaultMapping(false);
mappings.put(workflowName, mappingBean);
}
if (issueType != null) {
mappingBean.addIssueType(issueType);
} else {
mappingBean.setDefaultMapping(true);
}
}
if (scheme.getConfiguredDefaultWorkflow() == null) {
WorkflowMappingBean bean = mappings.get(JiraWorkflow.DEFAULT_WORKFLOW_NAME);
if (bean == null) {
bean =
new WorkflowMappingBean(
JiraWorkflow.DEFAULT_WORKFLOW_NAME, Lists.<String>newArrayList());
bean.setIssueTypes(Collections.<String>emptyList());
mappings.put(JiraWorkflow.DEFAULT_WORKFLOW_NAME, bean);
}
bean.setDefaultMapping(true);
}
return mappings;
}