protected MultiValuedMap<String, String> splitKeyValues(String params, String separator) { MultiValuedMap<String, String> data = new ArrayListValuedHashMap<>(); for (String line: params.split("\\r?\\n")) { String[] values = line.split(separator, 2); if (values.length == 2) { data.put(values[0].trim(), values[1].trim()); } } return data; }
@Override public boolean put(final K key, final V value) { return decorated().put(key, value); }
@Override public boolean put(final K key, final V value) { return decorated().put(transformKey(key), transformValue(value)); }
public void bindTrigger(Class<? extends Annotation> annotationClass, LifeCycleHook callback) { classToTriggers.put(annotationClass, callback); }
@Override protected Object putNewValue(MultiValuedMap<String, Object> map, String index, Object newValue) { return map.put(index, newValue); } }
public void bindTrigger(Class<? extends Annotation> annotationClass, LifeCycleHook callback) { classToTriggers.put(annotationClass, callback); }
@Override protected Object putNewValue(MultiValuedMap<Integer, Object> map, String index, Object newValue) { return map.put(Integer.valueOf(index), newValue); } }
public void bindTrigger(Class<? extends Annotation> annotationClass, String fieldOrMethodName, LifeCycleHook callback) { fieldsToTriggers.put(Pair.of(annotationClass, fieldOrMethodName), callback); }
public void bindTrigger(Class<? extends Annotation> annotationClass, String fieldOrMethodName, LifeCycleHook callback) { fieldsToTriggers.put(Pair.of(annotationClass, fieldOrMethodName), callback); }
/** * Adds a new mapping between a column position and a header. * The header may already be present, in which case the column position is * added to the list of column positions mapped to the header. * * @param k The column position for the mapping * @param v The header to be associated with the column position */ public void put(int k, String v) { if(k >= positionToHeader.length) { positionToHeader = Arrays.copyOf(positionToHeader, k+1); positionToHeader[k] = v; } headerToPosition.put(v, k); } }
public void addExportFeatures(Type t, String baseFeatureName) { this.programmaticFeatures.put(t.getName(), baseFeatureName); }
/** * Indicates, that class should be constructed using given constructor parameters. Constructor will be selected * based on constructor parameter's types. * * @param clazz class to instantiate * @param constructorParameters constructor parameters * @return itself * @see ConstructorParameters */ public AbstractAssertion create(final Class<?> clazz, final ConstructorParameters constructorParameters) { checkNotNull("clazz", clazz); checkNotNull("constructorParameters", constructorParameters); this.constructorParameters.put(clazz, constructorParameters); return this; }
public static void finishCallback(String desc) { if (recording()) { System.out.println("Finishing execution: " + desc); runs.put(desc, currentRun); } }
@BeforeAll static void beforeAll() { CLASS_AND_CONSTRUCTOR_PARAMETERS.put(UserDefinedClass.class, null); }
@Override public MultiValuedMap<String, String> indexFeatureValue(String aFieldPrefix, AnnotationFS aAnnotation, String aFeaturePrefix, AnnotationFeature aFeature) { FeatureSupport<?> featSup = featureSupportRegistry.getFeatureSupport(aFeature); String featureValue = featSup.renderFeatureValue(aFeature, aAnnotation); MultiValuedMap<String, String> values = new HashSetValuedHashMap<String, String>(); if (isEmpty(featureValue)) { return values; } values.put(aFieldPrefix + aFeaturePrefix + ATTRIBUTE_SEP + aFeature.getUiName(), featureValue); return values; } }
@Override public MultiValuedMap<String, String> indexFeatureValue(String aFieldPrefix, AnnotationFS aAnnotation, String aFeaturePrefix, AnnotationFeature aFeature) { FeatureSupport<?> featSup = featureSupportRegistry.getFeatureSupport(aFeature); String featureValue = featSup.renderFeatureValue(aFeature, aAnnotation); MultiValuedMap<String, String> values = new HashSetValuedHashMap<String, String>(); if (isEmpty(featureValue)) { return values; } values.put(aFieldPrefix + aFeaturePrefix + ATTRIBUTE_SEP + aFeature.getUiName(), featureValue); return values; } }
/** * Indicates, that class should be constructed using given constructor parameters. Constructor will be selected * based on constructor parameter's types. * * @param qualifiedClassName class to instantiate * @param constructorParameters constructor parameters * @return itself * @see ConstructorParameters */ public AbstractAssertion create(final String qualifiedClassName, final ConstructorParameters constructorParameters) { checkNotBlank("qualifiedClassName", qualifiedClassName); checkNotNull("constructorParameters", constructorParameters); final Class<?> clazz = ClassLoader.loadClass(qualifiedClassName); this.constructorParameters.put(clazz, constructorParameters); return this; }
private static void computeDescendants() { descendants.clear(); for (RObjectType rType : RObjectType.values()) { for (RObjectType ancestor : getAncestors(rType)) { descendants.put(ObjectTypes.getObjectType(ancestor.getJaxbClass()), rType); } } }
private void registerSchemaDescription(SchemaDescription desc) { if (desc.getUsualPrefix() != null) { namespacePrefixMapper.registerPrefix(desc.getNamespace(), desc.getUsualPrefix(), desc.isDefault()); if (desc.isDeclaredByDefault()) { namespacePrefixMapper.addDeclaredByDefault(desc.getUsualPrefix()); } } parsedSchemas.put(desc.getNamespace(), desc); schemaDescriptions.add(desc); }
@Test void Should_Use_User_Constructor_Parameters() { // given final Class[] classesToTest = { ClassWithSyntheticConstructor.class }; final ConstructorParameters parameters = new ConstructorParameters(new Object[]{ "string" }, new Class[]{ String.class }); final MultiValuedMap<Class<?>, ConstructorParameters> constructorParameters = spy(new ArrayListValuedHashMap<>()); constructorParameters.put(ClassWithSyntheticConstructor.class, parameters); final ConstructorTester constructorTester = new ConstructorTester(); constructorTester.setUserDefinedConstructors(constructorParameters); // when final Throwable result = catchThrowable(() -> constructorTester.testAll(classesToTest)); // then assertThat(result).isNull(); verify(constructorParameters).get(ClassWithSyntheticConstructor.class); }