import java.net.URL;

import org.codelibs.core.net.URLUtil;
import org.junit.Test;

/**
 * @author koichik
 *
 */
public class FileUtilTest {

    URL url = ResourceUtil.getResource(getClass().getName().replace('.', '/') + ".txt");

    File inputFile = URLUtil.toFile(url);

    /**
     * @throws Exception
     */
    @Test
    public void testFileToFile() throws Exception {

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isInstance(value)) {
            return type.cast(value);
        }
        if (type.isEnum() && type.getName().equals(value.getDeclaringClass().getName())) {
            return type.cast(Enum.valueOf(Cast.uncheckedNonnullCast(type.asSubclass(Enum.class)), value.name()));
        }
        return null;
    }

                .getDimSize(1),
            3);

  auto it = fused_lstm_func_.getBody().back().rbegin();
  EXPECT_EQ(it->getName().getStringRef(),
            mlir::func::ReturnOp::getOperationName());
  it++;  // tensor_cast
  it++;  // lstm
  EXPECT_EQ(it->getName().getStringRef(),
            mlir::TFL::LSTMOp::getOperationName());
  EXPECT_EQ(it->getNumOperands(), 24);
  EXPECT_EQ(it->getNumResults(), 1);

                val propertyNames = packageFragmentProto.`package`.propertyList
                    .map { propertyProto -> nameResolver.getName(propertyProto.name) }

                val functionNames = packageFragmentProto.`package`.functionList
                    .map { functionProto -> nameResolver.getName(functionProto.name) }

                val callableNames = (propertyNames + functionNames).distinct()

                return annotations.stream().filter(annotation -> annotation.getType().getName().endsWith("Nullable")).collect(toSet());
            }
        };
    }

    static DescribedPredicate<JavaMember> annotatedMaybeInSupertypeWith(final Class<? extends Annotation> annotationType) {
        return annotatedMaybeInSupertypeWith(annotationType.getName());
    }

                p.getActivation().getFile().getMissing(),
                clone.getActivation().getFile().getMissing());
        assertEquals(
                p.getActivation().getProperty().getName(),
                clone.getActivation().getProperty().getName());
        assertEquals(
                p.getActivation().getProperty().getValue(),
                clone.getActivation().getProperty().getValue());
        assertEquals(

            super(taskDependencyFactory, dependency);
            this.type = type;
            this.fileProvider = fileProvider;
        }

        @Override
        public String getName() {
            return getFile().getName();
        }

        @Override
        public String getExtension() {
            return "";
        }

        @Override
        public String getType() {

                        _INVOKEVIRTUAL(generatedType, "getConventionMapping", RETURN_CONVENTION_MAPPING);
                        // GENERATE convention.ineligible(__property.getName()__)
                        _LDC(property.getName());
                        _INVOKEINTERFACE(CONVENTION_MAPPING_TYPE, "ineligible", RETURN_VOID_FROM_STRING);
                    }
                }
                _RETURN();

        if (typeParameters.length > 0) {
            builder.append('<');
            for (TypeVariable<?> typeVariable : typeParameters) {
                builder.append(typeVariable.getName());
                for (java.lang.reflect.Type bound : typeVariable.getBounds()) {
                    builder.append(':');
                    visitType(bound, builder);
                }
            }

            report.getRequired().convention(providers.provider(() -> report.getName().equals(reportFormat.get())));
            report.getOutputLocation().convention(layout.getProjectDirectory().file(providers.provider(() -> {
                String fileSuffix = report.getName().equals("text") ? "txt" : report.getName();
                return new File(reportsDir.get().getAsFile(), baseName + "." + fileSuffix).getAbsolutePath();