Java Extractor类代码示例

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private static Extractor<Location, String> lastUriPart() {
    return new Extractor<Location, String>() {
        @Override
        public String extract(Location input) {
            return input.asURI().toString()
                    .replaceAll("/$", "")
                    .replaceAll(".*/", "");
        }
    };
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private Extractor<JavaMember, String> memberIdentifier() {
    return new Extractor<JavaMember, String>() {
        @Override
        public String extract(JavaMember input) {
            return input.getOwner().getSimpleName() + "#" + input.getName();
        }
    };
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private Extractor<PathParameter, Optional<String>> patternToOptionalOfString() {
    return new Extractor<PathParameter, Optional<String>>() {
        @Override
        public Optional<String> extract(PathParameter pathParameter) {
            return pathParameter.getRegex().isPresent()?
                    Optional.of(pathParameter.getRegex().get().pattern()):
                    Optional.<String>absent();
        }
    };
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
/**
 * Behavior is described in {@link AbstractIterableAssert#extracting(Extractor)}
 * @param <F> type of elements to extract a value from
 * @param <T> the extracted value type
 * @param objects the elements to extract a value from
 * @param extractor the extractor function
 * @return the extracted values
 */
public static <F, T> List<T> extract(Iterable<? extends F> objects, Extractor<? super F, T> extractor) {
  checkObjectToExtractFromIsNotNull(objects);
  List<T> result = newArrayList();

  for (F object : objects) {
    final T newValue = extractor.extract(object);
    result.add(newValue);
  }

  return result;
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Override
public Tuple extract(T input) {
  checkArgument(fieldsOrProperties != null, "The names of the fields/properties to read should not be null");
  checkArgument(fieldsOrProperties.length > 0, "The names of the fields/properties to read should not be empty");
  checkArgument(input != null, "The object to extract fields/properties from should not be null");

  List<Extractor<T, Object>> extractors = buildExtractors();
  List<Object> values = extractValues(input, extractors);
  
  return new Tuple(values.toArray());
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private List<Object> extractValues(T input, List<Extractor<T, Object>> singleExtractors) {
  List<Object> values = new ArrayList<>();
  
  for (Extractor<T, Object> extractor : singleExtractors) {
    values.add(extractor.extract(input));
  }
  return values;
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private List<Extractor<T, Object>> buildExtractors() {
  List<Extractor<T, Object>> result = new ArrayList<>();
  
  for (String name : fieldsOrProperties) {
    result.add(new ByNameSingleExtractor<T>(name));
  }
  
  return result;
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> doFlatExtracting(Extractor<? super ELEMENT, ? extends Collection<V>> extractor) {
  List<V> result = newArrayList();
  final List<? extends Collection<V>> extractedValues = FieldsOrPropertiesExtractor.extract(actual, extractor);

  for (Collection<? extends V> iterable : extractedValues) {
    result.addAll(iterable);
  }

  return newListAssertInstance(result);
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private <V, C extends Collection<V>> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> doFlatExtracting(Extractor<? super ELEMENT, C> extractor) {
  final List<C> extractedValues = FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), extractor);

  final List<V> result = newArrayList();
  for (C e : extractedValues) {
    result.addAll(e);
  }

  return newListAssertInstance(result);
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
private <U, C extends Collection<U>> ObjectArrayAssert<U> doFlatExtracting(Extractor<? super T, C> extractor) {
  final List<C> extractedValues = FieldsOrPropertiesExtractor.extract(Arrays.asList(array), extractor);

  final List<U> result = newArrayList();
  for (C e : extractedValues) {
    result.addAll(e);
  }

  return new ObjectArrayAssert<>(IterableUtil.toArray(result));
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Test
 public void should_extract_tuples_from_fields_or_properties() {
Extractor<Employee, Tuple> extractor = new ByNameMultipleExtractor<>("id", "age");

Tuple extractedValue = extractor.extract(yoda);
assertThat(extractedValue).isEqualTo(tuple(1L, 800));
 }
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Test
 public void should_extract_tuples_with_consistent_iteration_order() {
Extractor<Employee, Tuple> extractor = new ByNameMultipleExtractor<>("id", "name.first", "age");

Tuple extractedValues = extractor.extract(yoda);
assertThat(extractedValues).isEqualTo(tuple(1L, "Yoda", 800));
 }
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Test
public void should_let_anonymous_class_extractor_runtime_exception_bubble_up() {
  thrown.expect(RuntimeException.class, "age > 100");
  assertThat(employees).extracting(new Extractor<Employee, String>() {
    @Override
    public String extract(Employee employee) {
      if (employee.getAge() > 100) throw new RuntimeException("age > 100");
      return employee.getName().getFirst();
    }
  });
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Test
public void should_allow_assertions_on_extractor_assertions_extracted_from_given_array_compatibility() {
  assertThat(employees).extracting(new Extractor<Employee, String>() {
    @Override
    public String extract(Employee input) {
      return input.getName().getFirst();
    }
  }).containsOnly("Yoda", "Luke");
}
 

import org.assertj.core.api.iterable.Extractor; //导入依赖的package包/类
@Test
public void should_allow_assertions_on_extractor_assertions_extracted_from_given_array_compatibility_runtimeexception() {
  thrown.expect(RuntimeException.class);
  assertThat(employees).extracting(new Extractor<Employee, String>() {
    @Override
    public String extract(Employee input) {
      if (input.getAge() > 100) {
        throw new RuntimeException("age > 100");
      }
      return input.getName().getFirst();
    }
  });
}