java类javax.annotation.processing.Filer的实例源码

private void writeServices() {
    for (Map.Entry<Filer,Map<String,SortedSet<ServiceLoaderLine>>> outputFiles : outputFilesByProcessor.entrySet()) {
        Filer filer = outputFiles.getKey();
        for (Map.Entry<String,SortedSet<ServiceLoaderLine>> entry : outputFiles.getValue().entrySet()) {
            try {
                FileObject out = filer.createResource(StandardLocation.CLASS_OUTPUT, "", entry.getKey(),
                        originatingElementsByProcessor.get(filer).get(entry.getKey()).toArray(new Element[0]));
                OutputStream os = out.openOutputStream();
                try {
                    PrintWriter w = new PrintWriter(new OutputStreamWriter(os, "UTF-8"));
                    for (ServiceLoaderLine line : entry.getValue()) {
                        line.write(w);
                    }
                    w.flush();
                    w.close();
                } finally {
                    os.close();
                }
            } catch (IOException x) {
                processingEnv.getMessager().printMessage(Kind.ERROR, "Failed to write to " + entry.getKey() + ": " + x.toString());
            }
        }
    }
}

@Override
public boolean process(Set<? extends TypeElement> typeElements, RoundEnvironment roundEnv) {
    if (typeElements.size() == 0) {
        return true;
    }

    for (TypeElement typeElement : typeElements) {
        for (Element element : roundEnv.getElementsAnnotatedWith(typeElement)) {
            T entity = element.getAnnotation(targetAnnotation());
            SourceGenerator generator = createGenerator(element, entity, roundEnv);
            Filer filer = super.processingEnv.getFiler();
            try {
                List<JavaFile> javaFile = generator.createJavaFile(element);
                for (JavaFile file : javaFile) {
                    file.writeTo(filer);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return false;
}

public void writeInto(final Filer pFiler, final Messager pMessager) {
    // prepare generated class
    final GeneratedClass lGeneratedClass = new GeneratedClass(mEnclosingClass, mMethods);

    final TypeSpec lTypeSpecGeneratedClass = lGeneratedClass.buildTypeSpec();
    final String lPackageName = lGeneratedClass.packageName();

    // create generated class to a file
    try {
        JavaFile.builder(lPackageName, lTypeSpecGeneratedClass)
                .build()
                .writeTo(pFiler);
    } catch (IOException pE) {
        logError(pMessager, mEnclosingClass, "error while writing generated class");
    }
}

public void generateMappingTable(Filer filer) throws IOException {
    if (routerTable.isEmpty()) {
        return;
    }
    FieldSpec tableFieldSpec = FieldSpec.builder(Map.class, "routerTable")
            .addModifiers(Modifier.PRIVATE)
            .build();
    MethodSpec initTableMethodSpec = getInitTableMethodSpec();
    MethodSpec queryTableMethodSpec = getqueryTableMethodSpec();
    MethodSpec constructorMethodSpec = getconstructorMethodSpec(tableFieldSpec, initTableMethodSpec);
    MethodSpec addRouterMethodSpec = getAddRouterMethodSpec();
    TypeSpec routerTableClassTypeSpec = getRouterTableClassTypeSpec(tableFieldSpec, initTableMethodSpec, queryTableMethodSpec, constructorMethodSpec, addRouterMethodSpec);
    String packageName = Constants.GENERATED_PACKAGE_NAME;
    JavaFile javaFile = JavaFile.builder(packageName, routerTableClassTypeSpec).build();
    javaFile.writeTo(filer);
}

@Test
public void write_withIOException() throws Exception {
  final ProcessingEnvironment env = mock(ProcessingEnvironment.class);
  final Messager messager = mock(Messager.class);
  final Filer filer = mock(Filer.class);

  when(env.getMessager()).thenReturn(messager);
  when(env.getFiler()).thenReturn(filer);

  compiler.init(env);

  final JavaFile javaFile = mock(JavaFile.class);
  doThrow(IOException.class).when(javaFile).writeTo(any(Filer.class));

  compiler.writeSource(javaFile);

  verify(messager, times(1)).printMessage(eq(Diagnostic.Kind.ERROR), any());
}

public static boolean generateStaticCodeLoader(Filer filer, ProcessorPrinter pp){
    CodeBlock.Builder staticBuilder = CodeBlock.builder()
            //GlobalSetting.getgetDefault().setGsonVersion(xxx)
            .add("$T.getDefault().setGsonVersion($L);\n", ClassName.get(PKG_PROP, SN_GLOBAL_SETTING),
                    GlobalConfig.getInstance().getVersion());

    TypeSpec typeSpec = TypeSpec.classBuilder(SN_STATIC_LOADER)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addStaticBlock(staticBuilder.build())
            .addJavadoc(CodeBlock.of(DOC))
            .build();
    try {
        JavaFile javaFile = JavaFile.builder(PKG_DM_INTERNAL, typeSpec)
                .build();
       // System.out.println(javaFile.toString());
        javaFile.writeTo(filer);
    } catch (IOException e) {
        pp.error(TAG, "generateSharedProperties", Util.toString(e));
        return false;
    }
    return true;
}

public static boolean generateSharedProperties(Collection<FieldData> fields,
                                               Elements elements, Filer filer, ProcessorPrinter pp){
    final ClassName cn_sp = ClassName.get(PKG_DM_INTERNAL, SIMPLE_NAME_SHARED_PROP);
    CodeBlock.Builder staticBuilder = CodeBlock.builder();
    for(FieldData fd : fields){
        staticBuilder.add("$T.putToCache($S, $S, $L);\n", cn_sp, fd.getTypeCompat().toString(),
                fd.getPropertyName(), fd.getComplexType());
    }
    String classSimpleName = SIMPLE_NAME_SHARED_PROP + "_" + findBestIndex(elements);
    TypeSpec typeSpec = TypeSpec.classBuilder(classSimpleName)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addStaticBlock(staticBuilder.build())
            .addJavadoc(CodeBlock.of(DOC))
            .build();

    try {
        JavaFile javaFile = JavaFile.builder(PKG_DM_INTERNAL, typeSpec)
                .build();
       // System.out.println(javaFile.toString());
        javaFile.writeTo(filer);
    } catch (IOException e) {
        pp.error(TAG, "generateSharedProperties", Util.toString(e));
        return false;
    }
    return true;
}

/**
 * Initialize with the given details from the annotation processing enviornment
 */
public BindingManager(Elements elementUtils, Filer filer, Messager messager, Types typeUtils) {
    this.elementUtils = elementUtils;
    this.filer = filer;
    this.messager = messager;
    this.typeUtils = typeUtils;
    this.typeBuilderMap = new HashMap<>();

    stringTypeMirror = getType("java.lang.String");
    listTypeMirror = getType("java.util.List");
    mapTypeMirror = getType("java.util.Map");
    charSequenceTypeMirror = getType("java.lang.CharSequence");
    parcellableTypeMirror = getType("android.os.Parcelable");
    try {
        parcelClass = Class.forName("org.parceler.Parcel");
    } catch (ClassNotFoundException ignored) {
    }
}

public void write(Filer filer) throws IOException {
    FragmentCreatorBuilderGenerator fragmentCreatorBuilderGenerator =
            new FragmentCreatorBuilderGenerator(environment);
    FragmentCreatorReadGenerator fragmentCreatorReadGenerator = new FragmentCreatorReadGenerator(environment);

    TypeSpec.Builder classBuilder = createClassBuilder();

    classBuilder.addType(fragmentCreatorBuilderGenerator.create(model));
    classBuilder.addMethod(fragmentCreatorReadGenerator.createReadMethod(model));
    classBuilder.addMethod(fragmentCreatorBuilderGenerator.createBuilderNewBuilder(model, model.getArgsList()));

    TypeSpec outClass = classBuilder.build();
    JavaFile.builder(model.getPackageName(), outClass)
            .addFileComment("This file was generated by fragment-creator. Do not modify!")
            .build()
            .writeTo(filer);
}

public static void toJavaFile(Filer filer, Builder classBuilder, ClassName className,
    TypeElement... originatingElement)
{
    try
    {
        JavaFile javaFile =
            JavaFile.builder(className.packageName(), classBuilder.build()).build();

        JavaFileObject javaFileObject =
            filer.createSourceFile(className.reflectionName(), originatingElement);

        Writer writer = javaFileObject.openWriter();
        javaFile.writeTo(writer);
        writer.close();
    }
    catch (IOException e)
    {
        e.printStackTrace();
    }
}

public static void doWithOriAndPrintWriter(Filer filer, JavaFileManager.Location location, String relativePath, String filename, BiConsumer<String, PrintWriter> consumer){
    try {
        FileObject resource = filer.getResource(location, relativePath, filename);
        String data;
        try{
            CharSequence cs = resource.getCharContent(false);
            data = cs.toString();
            resource.delete();
        }catch (FileNotFoundException ignored){
            data = "";
        }
        resource = filer.createResource(location, relativePath, filename);

        try(OutputStream outputStream = resource.openOutputStream()){
            consumer.accept(data,new PrintWriter(outputStream));
        }
    } catch (IOException e) {
        note("do with resource file failed"+relativePath+filename+" Exception: " + e.toString());
    }
}

void brewJava(Filer filer) throws Exception {
    final TypeSpec.Builder spec = TypeSpec.classBuilder(mClassName)
            .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class)
                    .addMember("value", "$S", "unchecked")
                    .build())
            .addSuperinterface(ClassName.get(SQLiteSchema.class))
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addField(makeTablesField())
            .addField(makeMigrationsField())
            .addField(makeVersionField())
            .addStaticBlock(makeStaticInit())
            .addMethod(makeInit())
            .addMethod(makeGetVersion())
            .addMethod(makeGetTable())
            .addMethod(makeGetAllTables())
            .addMethod(makeAddMigration())
            .addMethod(makeGetAllMigrations());
    JavaFile.builder(mClassName.packageName(), spec.build())
            .addFileComment("Generated code from Alchemy. Do not modify!")
            .skipJavaLangImports(true)
            .build()
            .writeTo(filer);
}

ClassName brewJava(Filer filer) throws Exception {
    final ClassName modelName = ClassName.get(mElement);
    final TypeSpec.Builder spec = TypeSpec.classBuilder(mClassName.simpleName())
            .addAnnotation(AnnotationSpec.builder(SuppressWarnings.class)
                    .addMember("value", "$S", "TryFinallyCanBeTryWithResources")
                    .build())
            .addModifiers(Modifier.FINAL)
            .superclass(ParameterizedTypeName.get(ClassName.bestGuess("alchemy.sqlite.AbstractTable"), modelName))
            .addField(makeEntryField())
            .addMethod(makeInit())
            .addMethod(makeGetEntry())
            .addMethod(makeCreate());
    if (!mEntrySpec.getRelationSpecs().isEmpty()) {
        spec.addMethod(makeOnInsert());
    }
    JavaFile.builder(mClassName.packageName(), spec.build())
            .addFileComment("Generated code from Alchemy. Do not modify!")
            .skipJavaLangImports(true)
            .build()
            .writeTo(filer);
    return mClassName;
}

void brewJava(Filer filer) throws Exception {
    for (final EntrySpec entrySpec : mEntries.values()) {
        for (final RelationSpec relationSpec : entrySpec.getRelationSpecs()) {
            relationSpec.brewJava(filer);
        }
        entrySpec.brewJava(filer);
        entrySpec.getContractSpec().brewJava(filer);
    }
    for (final Map.Entry<String, Map<Element, TableSpec>> entry : mSchemas.entrySet()) {
        final SchemaSpec schemaSpec = new SchemaSpec(entry.getKey());
        for (final TableSpec tableSpec : entry.getValue().values()) {
            schemaSpec.putTable(tableSpec.getElement(), tableSpec.brewJava(filer));
        }
        schemaSpec.brewJava(filer);
    }
}

void brewJava(Filer filer) throws Exception {
    final TypeSpec.Builder spec = TypeSpec.classBuilder(mClassName.simpleName())
            .addOriginatingElement(mElement)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
    for (final ColumnSpec columnSpec : mColumnSpecs) {
        final String columnName = CaseFormat.LOWER_UNDERSCORE
                .to(CaseFormat.UPPER_UNDERSCORE, columnSpec.getColumnName());
        spec.addField(FieldSpec.builder(String.class, columnName, Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
                .initializer("$S", columnSpec.getColumnName())
                .build());
    }
    spec.addMethod(MethodSpec.constructorBuilder()
            .addModifiers(Modifier.PRIVATE)
            .build());
    JavaFile.builder(mClassName.packageName(), spec.build())
            .addFileComment("Generated code from Alchemy. Do not modify!")
            .skipJavaLangImports(true)
            .build()
            .writeTo(filer);
}

void brewJava(Filer filer) throws Exception {
    if (mPrimaryKey == null) {
        throw new IllegalStateException("No such field annotated with @PrimaryKey");
    }
    final ClassName modelName = ClassName.get(mElement);
    final TypeSpec.Builder spec = TypeSpec.classBuilder(mClassName.simpleName())
            .addOriginatingElement(mElement)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addSuperinterface(ParameterizedTypeName.get(ClassName.get(SQLiteEntry.class), modelName));
    for (final RelationSpec relationSpec : mRelationSpecs) {
        spec.addField(makeRelationField(relationSpec));
    }
    spec.addMethod(makeGetId());
    spec.addMethod(makeGetRelations());
    spec.addMethod(makeBind());
    spec.addMethod(makeMap());
    JavaFile.builder(mClassName.packageName(), spec.build())
            .addFileComment("Generated code from Alchemy. Do not modify!")
            .skipJavaLangImports(true)
            .build()
            .writeTo(filer);
}

/**
 * Writes this to {@code filer}.
 */
public void writeTo(Filer filer)
        throws IOException
{
    String fileName = packageName.isEmpty()
            ? typeSpec.name
            : packageName + "." + typeSpec.name;
    List<Element> originatingElements = typeSpec.originatingElements;
    JavaFileObject filerSourceFile = filer.createSourceFile(fileName,
            originatingElements.toArray(new Element[originatingElements.size()]));
    try (Writer writer = filerSourceFile.openWriter()) {
        writeTo(writer);
    }
    catch (Exception e) {
        try {
            filerSourceFile.delete();
        }
        catch (Exception ignored) {
        }
        throw e;
    }
}

@Override protected Iterable<? extends ProcessingStep> initSteps() {
  Messager messager = processingEnv.getMessager();
  Types types = processingEnv.getTypeUtils();
  Elements elements = processingEnv.getElementUtils();
  Filer filer = processingEnv.getFiler();

  AutoHttpGenerator autoHttpGenerator =
      new AutoHttpGenerator(filer, elements, messager);
  AutoHttpValidator autoHttpValidator =
      new AutoHttpValidator();
  MethodValidator methodValidator =
      new MethodValidator();

  return ImmutableList.of(
      new AutoHttpProcessingStep(
          messager,
          autoHttpGenerator,
          autoHttpValidator,
          methodValidator)
  );
}

private File getProjectRoot() throws Exception {
    if (projectRoot == null) {
        Filer filer = processingEnv.getFiler();

        JavaFileObject dummySourceFile = filer.createSourceFile("dummy" + System.currentTimeMillis());

        String dummySourceFilePath = dummySourceFile.toUri().toString();

        if (dummySourceFilePath.startsWith("file:")) {
            if (!dummySourceFilePath.startsWith("file://")) {
                dummySourceFilePath = "file://" + dummySourceFilePath.substring("file:".length());
            }
        } else {
            dummySourceFilePath = "file://" + dummySourceFilePath;
        }

        URI cleanURI = new URI(dummySourceFilePath);

        File dummyFile = new File(cleanURI);

        projectRoot = dummyFile.getParentFile();
    }

    return projectRoot;
}

/** Writes this to {@code filer}. */
public void writeTo(Filer filer) throws IOException {
  String fileName = packageName.isEmpty()
      ? typeSpec.name
      : packageName + "." + typeSpec.name;
  List<Element> originatingElements = typeSpec.originatingElements;
  JavaFileObject filerSourceFile = filer.createSourceFile(fileName,
      originatingElements.toArray(new Element[originatingElements.size()]));
  try (Writer writer = filerSourceFile.openWriter()) {
    writeTo(writer);
  } catch (Exception e) {
    try {
      filerSourceFile.delete();
    } catch (Exception ignored) {
    }
    throw e;
  }
}

/** Writes this to {@code filer}. */
public void writeTo(Filer filer) throws IOException {
  String fileName = packageName.isEmpty()
      ? typeSpec.name
      : packageName + "." + typeSpec.name;
  List<Element> originatingElements = typeSpec.originatingElements;
  JavaFileObject filerSourceFile = filer.createSourceFile(fileName,
      originatingElements.toArray(new Element[originatingElements.size()]));
  try (Writer writer = filerSourceFile.openWriter()) {
    writeTo(writer);
  } catch (Exception e) {
    try {
      filerSourceFile.delete();
    } catch (Exception ignored) {
    }
    throw e;
  }
}

public void generateCode(Filer _filer) throws IOException {
    if (mSingleTableClasses.size() == 0) {
        return;
    }

    TypeSpec helloWorld = TypeSpec.classBuilder(CLASS_NAME)
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addMethod(generateMapCursorToModelMethod())
            .addMethod(generateMapModelToContentValuesMethod())
            .addMethod(generateGetTableFromModelMethod())
            .addMethod(generateGetTableFromModelClassMethod())
            .addMethods(generateCursorToModelMethods())
            .addMethods(generateModelToContentValuesMethods())
            .build();

    JavaFile javaFile = JavaFile.builder("com.tractive.android.etil", helloWorld)
            .build();

    javaFile.writeTo(_filer);
}

public void write(@NonNull Filer filer) throws IOException {
  final TypeSpec.Builder classBuilder = classBuilder(className)
      .addModifiers(PUBLIC_FINAL)
      .superclass(ParameterizedTypeName.get(TABLE, structureElementTypeName))
      .addMethod(constructor())
      .addField(structureField())
      .addFields(columnFields(filer))
      .addMethod(aliasOverride())
      .addMethod(mapper());
  if (hasAnyPersistedComplexColumns && !isView) {
    classBuilder.addMethod(queryPartsAddOverride(METHOD_ADD_DEEP_QUERY_PARTS));
    if (isQueryPartNeededForShallowQuery) {
      classBuilder.addMethod(queryPartsAddOverride(METHOD_ADD_SHALLOW_QUERY_PARTS));
    }
  }
  if (isView) {
    classBuilder.addMethod(perfectSelectionOverride());
  }
  writeSource(filer, classBuilder.build());
}

public void writeSource(Filer filer, ViewElement viewElement) throws IOException {
  final boolean isFullQueryNeeded = !viewElement.isFullQuerySameAsShallow();
  final RetrieveMethodsBodyBuilder retrieveMethodsBodyBuilder = RetrieveMethodsBodyBuilder.create(viewElement);

  final TypeSpec.Builder daoClassBuilder = TypeSpec.classBuilder(getGeneratedDaoClassNameString(viewElement.getViewElement()))
      .addModifiers(CLASS_MODIFIERS)
      .addField(schemaConstant(viewElement))
      .addMethod(shallowObjectFromCursorPosition(viewElement, retrieveMethodsBodyBuilder));

  if (isFullQueryNeeded) {
    daoClassBuilder.addMethod(fullObjectFromCursorPosition(viewElement, retrieveMethodsBodyBuilder));
  }

  if (viewElement.isInterface()) {
    daoClassBuilder.addType(interfaceImplementation(viewElement));
  }

  WriterUtil.writeSource(filer, daoClassBuilder.build(), viewElement.getPackageName());

  StructureWriter.from(viewElement, environment).write(filer);
}

public TypeSpec write(@NonNull Filer filer) throws IOException {
  final TypeSpec.Builder classBuilder = TypeSpec.classBuilder(className)
      .addModifiers(CLASS_MODIFIERS)
      .addTypeVariable(parentTableType)
      .addTypeVariable(nullabilityType)
      .superclass(superClass)
      .addMethod(constructor())
      .addMethod(toSqlArg())
      .addMethod(aliasOverride());
  if (transformerElement != null) {
    classBuilder.addMethod(cursorParserOverride(transformerElement))
        .addMethod(statementParserOverride(transformerElement));
  }
  if (unique) {
    classBuilder.addSuperinterface(ParameterizedTypeName.get(UNIQUE, nullabilityType));
  }
  final TypeSpec type = classBuilder.build();
  writeSource(filer, type);
  return type;
}

public void writeSource(Environment environment, GenClassesManagerStep managerStep) throws IOException {
  if (!environment.getAllTableElements().isEmpty()) {
    Filer filer = environment.getFiler();
    TypeSpec.Builder classBuilder = TypeSpec.classBuilder(CLASS_NAME_GENERATED_CLASSES_MANAGER)
        .addModifiers(CLASS_MODIFIERS)
        .addMethod(databaseConfigurator(environment))
        .addMethod(databaseSchemaCreator(environment, managerStep))
        .addMethod(clearData(environment))
        .addMethod(nrOfTables(environment))
        .addMethod(dbVersion(environment))
        .addMethod(dbName(environment))
        .addMethod(columnForValue(environment, managerStep));
    WriterUtil.writeSource(filer, classBuilder.build(), PACKAGE_ROOT);
    persistLatestStructure(environment);
  }
}

public void writeSource(Filer filer, TableElement tableElement) throws IOException {
  final TypeName tableElementTypeName = tableElement.getTableElementTypeName();
  final EntityEnvironment entityEnvironment = new EntityEnvironment(tableElement, tableElementTypeName);
  final TypeSpec.Builder daoClassBuilder = TypeSpec.classBuilder(entityEnvironment.getDaoClassNameString())
      .addModifiers(CLASS_MODIFIERS);
  final TypeSpec.Builder handlerClassBuilder = TypeSpec.classBuilder(entityEnvironment.getHandlerClassNameString())
      .addModifiers(CLASS_MODIFIERS);

  for (ModelPartGenerator generator : modelPartGenerators) {
    generator.write(daoClassBuilder, handlerClassBuilder, entityEnvironment);
  }

  WriterUtil.writeSource(filer, daoClassBuilder.build(), tableElement.getPackageName());
  WriterUtil.writeSource(filer, handlerClassBuilder.build());

  ColumnClassWriter.from(tableElement, environment, false).write(filer);
  StructureWriter.from(entityEnvironment, environment).write(filer);
}

default void writeServiceNames(Class<?> serviceClass, Filer filer, List<String> generatedClassNames) throws IOException {
    String resourceFile = "META-INF/services/" + serviceClass.getName();
    FileObject existingFile = filer.getResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
    List<String> lines = new ArrayList<>();
    try (Reader reader = existingFile.openReader(false)) {
        try (BufferedReader bufferedReader = new BufferedReader(reader)) {
            lines.addAll(bufferedReader.lines().collect(Collectors.toList()));
        }
    } catch (IOException e) {
        // Just ignore because reading from a non-existing file and there is no way to detect its existence
        // than open the input stream/reader.
    }

    lines.addAll(generatedClassNames);

    FileObject newFile = filer.createResource(StandardLocation.CLASS_OUTPUT, "", resourceFile);
    try (Writer writer = newFile.openWriter()) {
        try (BufferedWriter bufferedWriter = new BufferedWriter(writer)) {
            for (String line : lines) {
                bufferedWriter.write(line);
                bufferedWriter.newLine();
            }
        }
    }
}

@Override
public void generate(TypeElement clazz, Filer filer) throws IOException {
    if (clazz.getKind() != ElementKind.INTERFACE) {
        throw new GeneratorException(clazz, "Should be an interface");
    }
    Bean annotation = clazz.getAnnotation(Bean.class);
    PackageElement packageElem = Models.getPackage(clazz);
    String packageName = packageElem.getQualifiedName().toString();
    String simpleName = clazz.getSimpleName().toString();
    String beanName = simpleName + "Bean";
    String beanFullName = packageName + "." + beanName;
    TypeName beanTypeName = ClassName.get(packageName, beanName);
    String builderName = simpleName + "Builder";
    ClassName builderClassName = ClassName.get(packageName, builderName);
    String extractorName = simpleName + "PropNameExtractor";
    BeanInfo info = BeanInfo.fromType(clazz, models);
    boolean shouldHaveNonDefaultConstructor = info.shouldHaveNonDefaultConstructor();

    JavaFile.builder(packageName, genBean(info, beanName, shouldHaveNonDefaultConstructor, builderClassName)).build().writeTo(filer);
    JavaFile.builder(packageName, genBuilder(info, ClassName.get(packageName, builderName), builderName, beanTypeName, beanFullName)).build().writeTo(filer);
    if (annotation.propNameExtractor()) {
        JavaFile.builder(packageName, getPropNameExtractor(info, extractorName)).build().writeTo(filer);
    }
}

/**
 * Test of getFileObjectWriterInClassOutput method, of class FileWriterServices.
 * @throws java.lang.Exception
 */
@Test
public void testGetFileObjectWriterInClassOutput() throws Exception {
    System.out.println("getFileObjectWriterInClassOutput");
    String pkg = "PKG";
    String name= "NAME";
    FileObject fileObject = mock(FileObject.class);
    Messager messager = mock(Messager.class);
    Filer filer = mock(Filer.class);
    Writer writer = mock(Writer.class);
    BodyWriter bodyWriter = mock(BodyWriter.class);
    FileWriterServices instance = spy(new FileWriterServices(messager, filer));
    instance.bodyWriter = bodyWriter;

    when(filer.createResource(eq(StandardLocation.CLASS_OUTPUT), eq(pkg), eq(name))).thenReturn(fileObject);
    when(fileObject.openWriter()).thenReturn(writer);
    Writer result = instance.getFileObjectWriterInClassOutput(pkg, name);
    assertThat(result).isEqualTo(writer);
}