@Override
public void drawScreen(int x, int y, float f) {
super.drawScreen(x, y, f);
String text1 =
this.machine.storage.getEnergyStored()
+ "/"
+ this.machine.storage.getMaxEnergyStored()
+ " RF";
if (x >= guiLeft + 16 && y >= guiTop + 5 && x <= guiLeft + 23 && y <= guiTop + 89) {
this.func_146283_a(Collections.singletonList(text1), x, y);
}
String text3 =
this.machine.tank.getFluidAmount()
+ "/"
+ this.machine.tank.getCapacity()
+ " mB "
+ FluidRegistry.WATER.getLocalizedName(this.machine.tank.getFluid());
if (x >= guiLeft + 27 && y >= guiTop + 5 && x <= guiLeft + 33 && y <= guiTop + 70) {
this.func_146283_a(Collections.singletonList(text3), x, y);
}
String text2 =
this.machine.coffeeCacheAmount
+ "/"
+ this.machine.coffeeCacheMaxAmount
+ " "
+ StatCollector.translateToLocal("info." + ModUtil.MOD_ID_LOWER + ".gui.coffee");
if (x >= guiLeft + 40 && y >= guiTop + 25 && x <= guiLeft + 49 && y <= guiTop + 56) {
this.func_146283_a(Collections.singletonList(text2), x, y);
}
}
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
messageConverter = createMock(HttpMessageConverter.class);
expect(messageConverter.getSupportedMediaTypes())
.andReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
replay(messageConverter);
processor =
new RequestResponseBodyMethodProcessor(
Collections.<HttpMessageConverter<?>>singletonList(messageConverter));
reset(messageConverter);
Method handle = getClass().getMethod("handle1", String.class, Integer.TYPE);
paramRequestBodyString = new MethodParameter(handle, 0);
paramInt = new MethodParameter(handle, 1);
returnTypeString = new MethodParameter(handle, -1);
returnTypeInt = new MethodParameter(getClass().getMethod("handle2"), -1);
returnTypeStringProduces = new MethodParameter(getClass().getMethod("handle3"), -1);
paramValidBean = new MethodParameter(getClass().getMethod("handle4", SimpleBean.class), 0);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
}
/** Test for creating zobjects with relationships */
@Test
@SuppressWarnings("serial")
public void createAndDeleteRelated() throws Exception {
SaveResult saveResult =
module.create(ZObjectType.Account, Collections.singletonList(testAccount())).get(0);
assertTrue(saveResult.isSuccess());
final String accountId = saveResult.getId();
try {
SaveResult result =
module
.create(
ZObjectType.Contact,
Collections.<Map<String, Object>>singletonList(
new HashMap<String, Object>() {
{
put("Country", "US");
put("FirstName", "John");
put("LastName", "Doe");
put("AccountId", accountId);
}
}))
.get(0);
assertTrue(result.isSuccess());
DeleteResult deleteResult =
module.delete(ZObjectType.Contact, Arrays.asList(result.getId())).get(0);
assertTrue(deleteResult.isSuccess());
} finally {
module.delete(ZObjectType.Account, Arrays.asList(accountId)).get(0);
}
}
public void testConfigureRequestGoals() throws Exception {
Properties props = new Properties();
InvokerProperties facade = new InvokerProperties(props);
InvocationRequest request = new DefaultInvocationRequest();
request.setGoals(Collections.singletonList("test"));
facade.configureInvocation(request, 0);
assertEquals(Collections.singletonList("test"), request.getGoals());
props.setProperty("invoker.goals", "verify");
facade.configureInvocation(request, 0);
assertEquals(Collections.singletonList("verify"), request.getGoals());
props.setProperty("invoker.goals", " ");
facade.configureInvocation(request, 0);
assertEquals(Arrays.asList(new String[0]), request.getGoals());
props.setProperty("invoker.goals", " clean , test verify ");
facade.configureInvocation(request, 0);
assertEquals(Arrays.asList(new String[] {"clean", "test", "verify"}), request.getGoals());
props.setProperty("invoker.goals", "");
facade.configureInvocation(request, 0);
assertEquals(Arrays.asList(new String[0]), request.getGoals());
}
private static List<XmlElementDescriptor> computeRequiredSubTags(XmlElementsGroup group) {
if (group.getMinOccurs() < 1) return Collections.emptyList();
switch (group.getGroupType()) {
case LEAF:
XmlElementDescriptor descriptor = group.getLeafDescriptor();
return descriptor == null
? Collections.<XmlElementDescriptor>emptyList()
: Collections.singletonList(descriptor);
case CHOICE:
LinkedHashSet<XmlElementDescriptor> set = null;
for (XmlElementsGroup subGroup : group.getSubGroups()) {
List<XmlElementDescriptor> descriptors = computeRequiredSubTags(subGroup);
if (set == null) {
set = new LinkedHashSet<XmlElementDescriptor>(descriptors);
} else {
set.retainAll(descriptors);
}
}
if (set == null || set.isEmpty()) {
return Collections.singletonList(null); // placeholder for smart completion
}
return new ArrayList<XmlElementDescriptor>(set);
default:
ArrayList<XmlElementDescriptor> list = new ArrayList<XmlElementDescriptor>();
for (XmlElementsGroup subGroup : group.getSubGroups()) {
list.addAll(computeRequiredSubTags(subGroup));
}
return list;
}
}
protected OutboundEndpoint createTestOutboundEndpoint(
String uri,
Filter filter,
SecurityFilter securityFilter,
Transformer transformer,
Transformer responseTransformer,
MessageExchangePattern exchangePattern,
TransactionConfig txConfig)
throws EndpointException, InitialisationException {
EndpointURIEndpointBuilder endpointBuilder = new EndpointURIEndpointBuilder(uri, muleContext);
if (filter != null) {
endpointBuilder.addMessageProcessor(new MessageFilter(filter));
}
if (securityFilter != null) {
endpointBuilder.addMessageProcessor(new SecurityFilterMessageProcessor(securityFilter));
}
if (transformer != null) {
endpointBuilder.setMessageProcessors(
Collections.<MessageProcessor>singletonList(transformer));
}
if (responseTransformer != null) {
endpointBuilder.setResponseMessageProcessors(
Collections.<MessageProcessor>singletonList(responseTransformer));
}
endpointBuilder.setExchangePattern(exchangePattern);
endpointBuilder.setTransactionConfig(txConfig);
customizeEndpointBuilder(endpointBuilder);
return endpointBuilder.buildOutboundEndpoint();
}
public void testTwoPlatformsoverSameSDK() throws Exception {
final File binDir = new File(getWorkDir(), "boot"); // NOI18N
binDir.mkdir();
final File jdocFile1 = new File(getWorkDir(), "jdoc1"); // NOI18N
jdocFile1.mkdir();
final File jdocFile2 = new File(getWorkDir(), "jdoc2"); // NOI18N
jdocFile2.mkdir();
JavaPlatformProviderImpl provider = Lookup.getDefault().lookup(JavaPlatformProviderImpl.class);
final URL binRoot = Utilities.toURI(binDir).toURL();
final ClassPath bootCp = ClassPathSupport.createClassPath(binRoot);
final List<URL> javadoc1 = Collections.singletonList(Utilities.toURI(jdocFile1).toURL());
final List<URL> javadoc2 = Collections.singletonList(Utilities.toURI(jdocFile2).toURL());
final TestJavaPlatform platform1 = new TestJavaPlatform("platform1", bootCp); // NOI18N
final TestJavaPlatform platform2 = new TestJavaPlatform("platform2", bootCp); // NOI18N
platform2.setJavadoc(javadoc2);
provider.addPlatform(platform1);
provider.addPlatform(platform2);
final JavadocForBinaryQuery.Result result1 = JavadocForBinaryQuery.findJavadoc(binRoot);
assertEquals(javadoc2, Arrays.asList(result1.getRoots()));
platform1.setJavadoc(javadoc1);
assertEquals(javadoc1, Arrays.asList(result1.getRoots()));
final JavadocForBinaryQuery.Result result2 = JavadocForBinaryQuery.findJavadoc(binRoot);
assertEquals(javadoc1, Arrays.asList(result2.getRoots()));
platform1.setJavadoc(Collections.<URL>emptyList());
assertEquals(javadoc2, Arrays.asList(result1.getRoots()));
assertEquals(javadoc2, Arrays.asList(result2.getRoots()));
}
private Optional<IdentifyResponse> detectedType(
final String fileName, final ContentFileType fileType, final float confidence) {
IdentifyResponse response =
new IdentifyResponse(
fileName, Collections.singletonList(fileType), Collections.singletonList(confidence));
return Optional.of(response);
}
@org.junit.Test
public void testIdentityMappingRealmB2A() throws Exception {
ClaimsManager claimsManager = new ClaimsManager();
claimsManager.setIdentityMapper(new CustomIdentityMapper());
RealmSupportClaimsHandler realmAHandler = new RealmSupportClaimsHandler();
realmAHandler.setRealm("A");
realmAHandler.setSupportedClaimTypes(Collections.singletonList(URI.create("Claim-A")));
RealmSupportClaimsHandler realmBHandler = new RealmSupportClaimsHandler();
realmBHandler.setRealm("B");
realmBHandler.setSupportedClaimTypes(Collections.singletonList(URI.create("Claim-B")));
RealmSupportClaimsHandler realmCHandler = new RealmSupportClaimsHandler();
realmCHandler.setRealm("B");
realmCHandler.setSupportedClaimTypes(Collections.singletonList(URI.create("Claim-C")));
List<ClaimsHandler> claimHandlers = new ArrayList<ClaimsHandler>();
claimHandlers.add(realmAHandler);
claimHandlers.add(realmBHandler);
claimHandlers.add(realmCHandler);
claimsManager.setClaimHandlers(Collections.unmodifiableList(claimHandlers));
ClaimCollection requestedClaims = createClaimCollection();
ClaimsParameters parameters = new ClaimsParameters();
parameters.setRealm("B");
parameters.setPrincipal(new CustomTokenPrincipal("ALICE"));
ProcessedClaimCollection claims =
claimsManager.retrieveClaimValues(requestedClaims, parameters);
Assert.assertEquals("Number of claims incorrect", 3, claims.size());
}
private Expression generateCopyExpression(
DefinedParamType type,
String inputParmId,
int inputIndex,
String outputParamId,
int outputIndex) {
// GOAL: ((InputSocket<Mat>) inputs[0]).getValue().assignTo(((OutputSocket<Mat>)
// outputs[0]).getValue());
final ClassOrInterfaceType outputType = new ClassOrInterfaceType("OutputSocket");
final ClassOrInterfaceType inputType = new ClassOrInterfaceType("InputSocket");
outputType.setTypeArgs(Collections.singletonList(type.getType()));
inputType.setTypeArgs(Collections.singletonList(type.getType()));
final MethodCallExpr copyExpression =
new MethodCallExpr(
getOrSetValueExpression(
new EnclosedExpr(new CastExpr(inputType, arrayAccessExpr(inputParmId, inputIndex))),
null),
"assignTo",
Collections.singletonList(
getOrSetValueExpression(
new EnclosedExpr(
new CastExpr(outputType, arrayAccessExpr(outputParamId, outputIndex))),
null)));
copyExpression.setComment(
new BlockComment(
" Sets the value of the input Mat to the output because this operation does not have a destination Mat. "));
return copyExpression;
}
private ExportTable convert(OutputDescription output) {
assert output != null;
BulkLoadExporterDescription desc = extract(output);
DuplicateRecordCheck duplicate = desc.getDuplicateRecordCheck();
if (duplicate == null) {
return new ExportTable(
desc.getModelType(),
desc.getTableName(),
desc.getColumnNames(),
desc.getTargetColumnNames(),
null,
Collections.singletonList(getOutputLocation(output)));
} else {
return new ExportTable(
desc.getModelType(),
desc.getTableName(),
desc.getColumnNames(),
desc.getTargetColumnNames(),
new DuplicateRecordErrorTable(
duplicate.getTableName(),
duplicate.getColumnNames(),
duplicate.getCheckColumnNames(),
duplicate.getErrorCodeColumnName(),
duplicate.getErrorCodeValue()),
Collections.singletonList(getOutputLocation(output)));
}
}
@Override
public List<Short> check(Environment env, Mutation mutation) {
List<ColumnUpdate> updates = mutation.getUpdates();
HashSet<String> ok = null;
if (updates.size() > 1) ok = new HashSet<String>();
VisibilityEvaluator ve = null;
for (ColumnUpdate update : updates) {
byte[] cv = update.getColumnVisibility();
if (cv.length > 0) {
String key = null;
if (ok != null && ok.contains(key = new String(cv, UTF_8))) continue;
try {
if (ve == null) ve = new VisibilityEvaluator(env);
if (!ve.evaluate(new ColumnVisibility(cv)))
return Collections.singletonList(Short.valueOf((short) 2));
} catch (BadArgumentException bae) {
return Collections.singletonList(new Short((short) 1));
} catch (VisibilityParseException e) {
return Collections.singletonList(new Short((short) 1));
}
if (ok != null) ok.add(key);
}
}
return null;
}
public void testMixedStrategyTableNoExist() throws Exception {
String template = "SELECT #result('id' 'int') FROM SUS1";
SQLTemplate query = new SQLTemplate(Object.class, template);
DataMap map = node.getEntityResolver().getDataMap("sus-map");
DataNode dataNode = createDataNode(map);
int sizeDB = getNameTablesInDB(dataNode).size();
MockOperationObserver observer = new MockOperationObserver();
setStrategy(ThrowOnPartialOrCreateSchemaStrategy.class.getName(), dataNode);
try {
dataNode.performQueries(Collections.singletonList((Query) query), observer);
Map<String, Boolean> nameTables = getNameTablesInDB(dataNode);
assertTrue(nameTables.get("sus1") != null || nameTables.get("SUS1") != null);
int sizeDB2 = getNameTablesInDB(dataNode).size();
assertEquals(2, sizeDB2 - sizeDB);
dataNode.performQueries(Collections.singletonList((Query) query), observer);
int sizeDB3 = getNameTablesInDB(dataNode).size();
assertEquals(sizeDB2, sizeDB3);
} finally {
DataNode dataNode2 = createDataNode(map);
dataNode2.setSchemaUpdateStrategy(
(SchemaUpdateStrategy)
Class.forName(dataNode2.getSchemaUpdateStrategyName()).newInstance());
dropTables(map, dataNode2, observer);
}
assertEquals(getNameTablesInDB(dataNode).size(), sizeDB);
}
@Test
public void testWithAlgorithmOverrides() throws ResolverException {
roleDesc
.getKeyDescriptors()
.add(buildKeyDescriptor(rsaCred1KeyName, UsageType.ENCRYPTION, rsaCred1.getPublicKey()));
config2.setDataEncryptionAlgorithms(
Collections.singletonList(EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES256));
config2.setKeyTransportEncryptionAlgorithms(
Collections.singletonList(EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15));
EncryptionParameters params = resolver.resolveSingle(criteriaSet);
Assert.assertNotNull(params);
Assert.assertEquals(
params.getKeyTransportEncryptionCredential().getPublicKey(), rsaCred1.getPublicKey());
Assert.assertEquals(
params.getKeyTransportEncryptionAlgorithm(),
EncryptionConstants.ALGO_ID_KEYTRANSPORT_RSA15);
Assert.assertNotNull(params.getKeyTransportKeyInfoGenerator());
Assert.assertNull(params.getDataEncryptionCredential());
Assert.assertEquals(
params.getDataEncryptionAlgorithm(), EncryptionConstants.ALGO_ID_BLOCKCIPHER_AES256);
Assert.assertNull(params.getDataKeyInfoGenerator());
}
/**
* Adds the "new" coiDisclosureAttachment to the CoiDisclosure Document. Before adding this method
* executes validation. If the validation fails the attachment is not added.
*/
public void addNewCoiDisclosureAttachment() {
this.refreshAttachmentReferences(
Collections.singletonList(this.getNewCoiDisclosureAttachment()));
this.syncNewFiles(Collections.singletonList(this.getNewCoiDisclosureAttachment()));
final AddCoiDisclosureAttachmentRule rule = new AddCoiDisclosureAttachmentRuleImpl();
final AddCoiDisclosureAttachmentEvent event =
new AddCoiDisclosureAttachmentEvent(
coiDisclosureForm.getDocument(), newCoiDisclosureAttachment);
assignDocumentId(
Collections.singletonList(this.getNewCoiDisclosureAttachment()),
this.createTypeToMaxDocNumber(getCoiDisclosure().getCoiDisclosureAttachments()));
if (rule.processAddCoiDisclosureAttachmentRules(event)) {
this.newCoiDisclosureAttachment.setCoiDisclosureId(getCoiDisclosure().getCoiDisclosureId());
newCoiDisclosureAttachment.setSequenceNumber(getCoiDisclosure().getSequenceNumber());
newCoiDisclosureAttachment.setEventTypeCode(getCoiDisclosure().getEventTypeCode() + "");
if (getCoiDisclosure().getCoiDisclProjects().size() > 0) {
newCoiDisclosureAttachment.setProjectId(
getCoiDisclosure().getCoiDisclProjects().get(0).getProjectId());
}
this.getCoiDisclosure().addAttachment(newCoiDisclosureAttachment);
getBusinessObjectService().save(newCoiDisclosureAttachment);
this.initCoiDisclosureAttachment();
}
}
protected IRExpression pushOuterForOuterSymbol() {
IRExpression root = pushOuter();
IType currentClass = getGosuClass();
while (currentClass instanceof IBlockClass) {
currentClass = currentClass.getEnclosingType();
IRMethod irMethod =
IRMethodFactory.createIRMethod(
currentClass,
OUTER_ACCESS,
currentClass.getEnclosingType(),
new IType[] {currentClass},
AccessibilityUtil.forOuterAccess(),
true);
root = callMethod(irMethod, null, Collections.singletonList(root));
}
IType outer = currentClass.getEnclosingType();
while (outer instanceof IBlockClass) {
IType enclosing = getRuntimeEnclosingType(outer);
IRMethod irMethod =
IRMethodFactory.createIRMethod(
outer,
OUTER_ACCESS,
enclosing,
new IType[] {outer},
AccessibilityUtil.forOuterAccess(),
true);
root = callMethod(irMethod, null, Collections.singletonList(root));
outer = enclosing;
}
return root;
}
public List<ApiObject> requestList(int method, ApiObject[] parameters) {
try {
switch (method) {
case LIST_OPTION_GROUPS:
return ApiObject.envelopeStringList(getOptionGroups());
case LIST_OPTION_NAMES:
return ApiObject.envelopeStringList(
getOptionNames(((ApiObject.String) parameters[0]).Value));
case LIST_BOOK_TAGS:
return ApiObject.envelopeStringList(getBookTags());
case LIST_ACTIONS:
return ApiObject.envelopeStringList(listActions());
case LIST_ACTION_NAMES:
{
final ArrayList<String> actions = new ArrayList<String>(parameters.length);
for (ApiObject o : parameters) {
actions.add(((ApiObject.String) o).Value);
}
return ApiObject.envelopeStringList(listActionNames(actions));
}
case LIST_ZONEMAPS:
return ApiObject.envelopeStringList(listZoneMaps());
case GET_PARAGRAPH_WORDS:
return ApiObject.envelopeStringList(
getParagraphWords(((ApiObject.Integer) parameters[0]).Value));
case GET_PARAGRAPH_WORD_INDICES:
return ApiObject.envelopeIntegerList(
getParagraphWordIndices(((ApiObject.Integer) parameters[0]).Value));
default:
return Collections.<ApiObject>singletonList(unsupportedMethodError(method));
}
} catch (Throwable e) {
return Collections.<ApiObject>singletonList(exceptionInMethodError(method, e));
}
}
@Nullable
public VcsCommittedViewAuxiliary createActions(
final DecoratorManager manager, @Nullable final RepositoryLocation location) {
final RootsAndBranches rootsAndBranches = new RootsAndBranches(myProject, manager, location);
refreshMergeInfo(rootsAndBranches);
final DefaultActionGroup popup = new DefaultActionGroup(myVcs.getDisplayName(), true);
popup.add(rootsAndBranches.getIntegrateAction());
popup.add(rootsAndBranches.getUndoIntegrateAction());
popup.add(new ConfigureBranchesAction());
final ShowHideMergePanel action =
new ShowHideMergePanel(manager, rootsAndBranches.getStrategy());
return new VcsCommittedViewAuxiliary(
Collections.<AnAction>singletonList(popup),
new Runnable() {
public void run() {
if (myMergeInfoUpdatesListener != null) {
myMergeInfoUpdatesListener.removePanel(rootsAndBranches);
rootsAndBranches.dispose();
}
}
},
Collections.<AnAction>singletonList(action));
}
public static void convertFormToConfiguration(
final StoredConfigurationImpl storedConfiguration,
final Map<String, String> ldapForm,
final Map<String, String> incomingLdapForm)
throws PwmUnrecoverableException {
{
final String newLdapURI = getLdapUrlFromFormConfig(ldapForm);
final StringArrayValue newValue = new StringArrayValue(Collections.singletonList(newLdapURI));
storedConfiguration.writeSetting(
PwmSetting.LDAP_SERVER_URLS, LDAP_PROFILE_KEY, newValue, null);
}
{ // proxy/admin account
final String ldapAdminDN = ldapForm.get(PARAM_LDAP_PROXY_DN);
final String ldapAdminPW = ldapForm.get(PARAM_LDAP_PROXY_PW);
storedConfiguration.writeSetting(
PwmSetting.LDAP_PROXY_USER_DN, LDAP_PROFILE_KEY, new StringValue(ldapAdminDN), null);
final PasswordValue passwordValue =
new PasswordValue(PasswordData.forStringValue(ldapAdminPW));
storedConfiguration.writeSetting(
PwmSetting.LDAP_PROXY_USER_PASSWORD, LDAP_PROFILE_KEY, passwordValue, null);
}
storedConfiguration.writeSetting(
PwmSetting.LDAP_CONTEXTLESS_ROOT,
LDAP_PROFILE_KEY,
new StringArrayValue(Collections.singletonList(ldapForm.get(PARAM_LDAP_CONTEXT))),
null);
{
final String ldapContext = ldapForm.get(PARAM_LDAP_CONTEXT);
storedConfiguration.writeSetting(
PwmSetting.LDAP_CONTEXTLESS_ROOT,
LDAP_PROFILE_KEY,
new StringArrayValue(Collections.singletonList(ldapContext)),
null);
}
{
final String ldapTestUserDN = ldapForm.get(PARAM_LDAP_TEST_USER);
storedConfiguration.writeSetting(
PwmSetting.LDAP_TEST_USER_DN, LDAP_PROFILE_KEY, new StringValue(ldapTestUserDN), null);
}
{ // set admin query
final String groupDN = ldapForm.get(PARAM_LDAP_ADMIN_GROUP);
final List<UserPermission> userPermissions =
Collections.singletonList(
new UserPermission(UserPermission.Type.ldapGroup, null, null, groupDN));
storedConfiguration.writeSetting(
PwmSetting.QUERY_MATCH_PWM_ADMIN, new UserPermissionValue(userPermissions), null);
}
// set context based on ldap dn
if (incomingLdapForm.containsKey(PARAM_APP_SITEURL)) {
ldapForm.put(PARAM_APP_SITEURL, incomingLdapForm.get(PARAM_APP_SITEURL));
}
storedConfiguration.writeSetting(
PwmSetting.PWM_SITE_URL, new StringValue(ldapForm.get(PARAM_APP_SITEURL)), null);
}
public static MutableSimpleModuleDeclaration declaration() {
return new MutableSimpleModuleDeclaration()
.setSimpleName(BinarySum.class.getSimpleName())
.setPorts(
Arrays.<MutablePort<?>>asList(
new MutableInPort()
.setSimpleName("num1")
.setType(MutableDeclaredType.fromType(Integer.class)),
new MutableInPort()
.setSimpleName("num2")
.setType(MutableDeclaredType.fromType(Integer.class)),
new MutableOutPort()
.setSimpleName("result")
.setType(MutableDeclaredType.fromType(Integer.class))
.setDeclaredAnnotations(
Collections.singletonList(
new MutableAnnotation()
.setDeclaration(CloudKeeperSerialization.class.getName())
.setEntries(
Collections.singletonList(
new MutableAnnotationEntry()
.setKey("value")
.setValue(
new String[] {
IntegerMarshaler.class.getName()
})))))))
.setDeclaredAnnotations(
Collections.singletonList(
MutableAnnotation.fromAnnotation(BinarySum.class.getAnnotation(Memory.class))));
}
@Test
public void canCreateEnumerationType() {
MockitoAnnotations.initMocks(this);
QName qName = QName.create("TestQName");
SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qName), true);
List<EnumTypeDefinition.EnumPair> listEnumPair = Collections.singletonList(enumPair);
Optional<EnumTypeDefinition.EnumPair> defaultValue = Optional.of(enumPair);
EnumerationType enumerationType =
EnumerationType.create(schemaPath, listEnumPair, defaultValue);
assertNotEquals("Description is not null", null, enumerationType.getDescription());
assertEquals("QName", BaseTypes.ENUMERATION_QNAME, enumerationType.getQName());
assertEquals("Should be empty string", "", enumerationType.getUnits());
assertNotEquals("Description should not be null", null, enumerationType.toString());
assertNotEquals("Reference is not null", null, enumerationType.getReference());
assertEquals("BaseType should be null", null, enumerationType.getBaseType());
assertEquals("Default value should be enumPair", enumPair, enumerationType.getDefaultValue());
assertEquals("getPath should equal schemaPath", schemaPath, enumerationType.getPath());
assertEquals("Status should be CURRENT", Status.CURRENT, enumerationType.getStatus());
assertEquals(
"Should be empty list", Collections.EMPTY_LIST, enumerationType.getUnknownSchemaNodes());
assertEquals("Values should be [enumPair]", listEnumPair, enumerationType.getValues());
assertEquals(
"Hash code of enumerationType should be equal",
enumerationType.hashCode(),
enumerationType.hashCode());
assertNotEquals("EnumerationType shouldn't equal to null", null, enumerationType);
assertEquals("EnumerationType should equals to itself", enumerationType, enumerationType);
assertNotEquals(
"EnumerationType shouldn't equal to object of other type", "str", enumerationType);
}
private void setRandomTripMode(final Trip trip, final Plan plan, boolean ffcard, boolean owcard) {
// carsharing is the new trip
if (possibleModes.length == 2) {
if (rng.nextBoolean()) {
if (owcard)
TripRouter.insertTrip(
plan,
trip.getOriginActivity(),
Collections.singletonList(new LegImpl("onewaycarsharing")),
trip.getDestinationActivity());
} else {
if (ffcard)
TripRouter.insertTrip(
plan,
trip.getOriginActivity(),
Collections.singletonList(new LegImpl("freefloating")),
trip.getDestinationActivity());
}
} else if (possibleModes.length == 1 && possibleModes[0] != null) {
if ((possibleModes[0].equals("freefloating") && ffcard)
|| (possibleModes[0].equals("onewaycarsharing") && owcard))
TripRouter.insertTrip(
plan,
trip.getOriginActivity(),
Collections.singletonList(new LegImpl(possibleModes[0])),
trip.getDestinationActivity());
} else
TripRouter.insertTrip(
plan, trip.getOriginActivity(), trip.getTripElements(), trip.getDestinationActivity());
}
private SyndFeed createFeed() {
SyndFeed feed = new SyndFeedImpl();
SyndPerson auteur = new SyndPersonImpl();
auteur.setName("Gildas Cuisinier");
auteur.setEmail("*****@*****.**");
feed.setTitle("RSS Veille Techno");
feed.setAuthors(Collections.singletonList(auteur));
feed.setDescription("RSS d'exemple !");
feed.setLink("http://svn.cyg.be/");
feed.setPublishedDate(new Date());
feed.setLanguage("fr");
SyndEntry entry = new SyndEntryImpl();
entry.setTitle("Ajout du projet Rome sur le SVN");
entry.setLink("https://rome.dev.java.net/");
SyndContent description = new SyndContentImpl();
description.setValue("Ajout d'un projet Rome sur le SVN afin de voir comment creer un RSS");
description.setType("text");
entry.setDescription(description);
entry.setAuthors(Collections.singletonList(auteur));
feed.getEntries().add(entry);
return feed;
}
/**
* Test method for {@link
* net.sf.hajdbc.balancer.AbstractBalancer#containsAll(java.util.Collection)}.
*/
@Test
public void containsAll() {
Balancer<Void, MockDatabase> balancer =
this.factory.createBalancer(Collections.<MockDatabase>emptySet());
assertTrue(balancer.containsAll(Collections.emptyList()));
assertFalse(balancer.containsAll(Collections.singletonList(this.databases[0])));
assertFalse(balancer.containsAll(Arrays.asList(this.databases[0], this.databases[1])));
assertFalse(balancer.containsAll(Arrays.asList(this.databases)));
balancer = this.factory.createBalancer(Collections.singleton(this.databases[0]));
assertTrue(balancer.containsAll(Collections.emptyList()));
assertTrue(balancer.containsAll(Collections.singletonList(this.databases[0])));
assertFalse(balancer.containsAll(Arrays.asList(this.databases[0], this.databases[1])));
assertFalse(balancer.containsAll(Arrays.asList(this.databases)));
balancer =
this.factory.createBalancer(
new HashSet<MockDatabase>(Arrays.asList(this.databases[0], this.databases[1])));
assertTrue(balancer.containsAll(Collections.emptyList()));
assertTrue(balancer.containsAll(Collections.singletonList(this.databases[0])));
assertTrue(balancer.containsAll(Arrays.asList(this.databases[0], this.databases[1])));
assertFalse(balancer.containsAll(Arrays.asList(this.databases)));
balancer =
this.factory.createBalancer(new HashSet<MockDatabase>(Arrays.asList(this.databases)));
assertTrue(balancer.containsAll(Collections.emptyList()));
assertTrue(balancer.containsAll(Collections.singletonList(this.databases[0])));
assertTrue(balancer.containsAll(Arrays.asList(this.databases[0], this.databases[1])));
assertTrue(balancer.containsAll(Arrays.asList(this.databases)));
}
public void testURIIllegal() {
try {
new DefaultGraphInfo(null, MediaType.XTM);
fail("Expected an exception for URI == null");
} catch (IllegalArgumentException ex) {
// noop.
}
try {
new DefaultGraphInfo(null, MediaType.XTM, -1);
fail("Expected an exception for URI == null");
} catch (IllegalArgumentException ex) {
// noop.
}
try {
new DefaultGraphInfo(null, Collections.singletonList(MediaType.XTM));
fail("Expected an exception for URI == null");
} catch (IllegalArgumentException ex) {
// noop.
}
try {
new DefaultGraphInfo(null, Collections.singletonList(MediaType.XTM), -1);
fail("Expected an exception for URI == null");
} catch (IllegalArgumentException ex) {
// noop.
}
}
@Test
public void testLabeledNetworkAttachedToThisInterfaceWhenNetworkIsAssignedToWrongInterface()
throws Exception {
String networkName = "networkA";
Network network = new Network();
network.setName(networkName);
VdsNetworkInterface nicToWhichLabeledNetworkShouldBeAttached =
createVdsNetworkInterfaceWithName("nicA");
VdsNetworkInterface nicImproperlyAssignedToNetwork = createVdsNetworkInterfaceWithName("nicB");
nicImproperlyAssignedToNetwork.setNetworkName(networkName);
List<VdsNetworkInterface> hostInterfaces =
Arrays.asList(nicToWhichLabeledNetworkShouldBeAttached, nicImproperlyAssignedToNetwork);
HostInterfaceValidator validator =
new HostInterfaceValidator(nicToWhichLabeledNetworkShouldBeAttached);
assertThat(
validator.networksAreAttachedToThisInterface(
hostInterfaces, Collections.singletonList(network)),
failsWith(
EngineMessage.LABELED_NETWORK_ATTACHED_TO_WRONG_INTERFACE,
ReplacementUtils.replaceWith(
HostInterfaceValidator.VAR_ASSIGNED_NETWORKS,
Collections.singletonList(networkName))));
}
@Override
public List<Object> apply(List<Object> arguments) {
Preconditions.checkArguments("string.match", arguments, expectedTypes);
if (LuaType.getTypeOf(arguments.get(0)) == LuaType.NUMBER) {
arguments.set(0, ToString.toString(arguments.get(0)));
return apply(arguments);
}
if (LuaType.getTypeOf(arguments.get(1)) == LuaType.NUMBER) {
arguments.set(1, ToString.toString(arguments.get(1)));
return apply(arguments);
}
if (((String) arguments.get(1)).isEmpty()) {
return Collections.singletonList(arguments.get(0));
}
Object[] index = new Find().apply(arguments).toArray();
if (index[0] == null) {
return Collections.singletonList((Object) null);
}
return Collections.singletonList(
(Object)
((String) arguments.get(0))
.substring(((Double) index[0]).intValue() - 1, ((Double) index[1]).intValue()));
}
static List<Range> mergeRanges(final List<Range> ranges) {
if (ranges.isEmpty()) {
return Collections.emptyList();
}
final List<Range> result = new ArrayList<Range>();
final Iterator<Range> it = ranges.iterator();
Range leftRange = it.next();
List<Range> merged = Collections.singletonList(leftRange);
while (it.hasNext()) {
// merge ranges as long as they're adjacent/overlapping
while (merged.size() == 1 && it.hasNext()) {
leftRange = merged.get(0);
Range rightRange = it.next();
merged = mergeRanges(leftRange, rightRange);
}
// when ranges weren't merge-able, add all but last, merge against last
if (merged.size() > 1) {
result.addAll(merged.subList(0, merged.size() - 1));
merged = Collections.singletonList(merged.get(merged.size() - 1));
}
}
result.addAll(merged);
return result;
}
@Nullable
private static List<String> getTasksTarget(Location location) {
if (location instanceof GradleTaskLocation) {
return ((GradleTaskLocation) location).getTasks();
}
PsiElement parent = location.getPsiElement();
while (parent.getParent() != null && !(parent.getParent() instanceof PsiFile)) {
parent = parent.getParent();
}
if (isCreateTaskMethod(parent)) {
final GrExpression[] arguments = ((GrMethodCallExpression) parent).getExpressionArguments();
if (arguments.length > 0
&& arguments[0] instanceof GrLiteral
&& ((GrLiteral) arguments[0]).getValue() instanceof String) {
return Collections.singletonList((String) ((GrLiteral) arguments[0]).getValue());
}
} else if (parent instanceof GrApplicationStatement) {
PsiElement shiftExpression = parent.getChildren()[1].getChildren()[0];
if (shiftExpression instanceof GrShiftExpressionImpl) {
PsiElement shiftiesChild = shiftExpression.getChildren()[0];
if (shiftiesChild instanceof GrReferenceExpression) {
return Collections.singletonList(shiftiesChild.getText());
} else if (shiftiesChild instanceof GrMethodCallExpression) {
return Collections.singletonList(shiftiesChild.getChildren()[0].getText());
}
} else if (shiftExpression instanceof GrMethodCallExpression) {
return Collections.singletonList(shiftExpression.getChildren()[0].getText());
}
}
return null;
}
@Before
public void setUp() throws Exception {
final CatalogManager catalogManager = CatalogManager.getInstance();
final Catalog catalog = catalogManager.createCatalog("PartOfTest");
srcCatalogVersion = catalogManager.createCatalogVersion(catalog, "ver1", null);
srcCatalogVersion.setLanguages(Collections.singletonList(getOrCreateLanguage("de")));
tgtCatalogVersion = catalogManager.createCatalogVersion(catalog, "ver2", null);
tgtCatalogVersion.setLanguages(Collections.singletonList(getOrCreateLanguage("de")));
LOG.info("Creating product");
final ComposedType composedType = TypeManager.getInstance().getComposedType(Product.class);
final Product productOne = createProduct("Product-One", composedType);
final Product productTwo = createProduct("Product-Two", composedType);
LOG.info("Creating product reference ");
catalogManager.createProductReference("foo", productOne, productTwo, Integer.valueOf(1));
LOG.info("Done catalog creation.");
final Europe1PriceFactory europe1 = Europe1PriceFactory.getInstance();
final Currency currency = C2LManager.getInstance().createCurrency("europe1/dr");
final Unit unit = ProductManager.getInstance().createUnit(null, "europe1/u", "typ");
final EnumerationValue enumValue =
EnumerationManager.getInstance()
.createEnumerationValue(Europe1Constants.TYPES.DISCOUNT_USER_GROUP, "test");
priceRowSpy =
Mockito.spy(
europe1.createPriceRow(
productTwo, null, null, enumValue, 0, currency, unit, 1, true, null, 0));
}
