1057

Committed 10 Jul 2026 10:31PM UTC coverage: 80.917% (+1.0%) from 79.903%

Build # 1057

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #546 from hazendaz/master

Modernize Collections and avoid security manager entirely in tests

Coverage Stats

692 of 986 branches covered (70.18%)

10 of 11 new or added lines in 9 files covered. (90.91%)

1 existing line in 1 file now uncovered.

1836 of 2269 relevant lines covered (80.92%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

47.27

/src/main/java/org/apache/ibatis/migration/io/JBoss6VFS.java

/*
 *    Copyright 2010-2026 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.migration.io;

import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A {@link VFS} implementation that works with the VFS API provided by JBoss 6.
 */
public class JBoss6VFS extends VFS {
  private static final Logger log = Logger.getLogger(JBoss6VFS.class.getName());

  /** A class that mimics a tiny subset of the JBoss VirtualFile class. */
  static class VirtualFile {
    static Class<?> VirtualFile;
    static Method getPathNameRelativeTo;
    static Method getChildrenRecursively;

    Object virtualFile;

    VirtualFile(Object virtualFile) {
      this.virtualFile = virtualFile;
    }

    String getPathNameRelativeTo(VirtualFile parent) {
      try {
        return invoke(getPathNameRelativeTo, virtualFile, parent.virtualFile);
      } catch (IOException e) {
        // This exception is not thrown by the called method
        log.log(Level.SEVERE, "This should not be possible. VirtualFile.getPathNameRelativeTo() threw IOException.");
        return null;
      }
    }

    List<VirtualFile> getChildren() throws IOException {
      List<?> objects = invoke(getChildrenRecursively, virtualFile);
      List<VirtualFile> children = new ArrayList<>(objects.size());
      for (Object object : objects) {
        children.add(new VirtualFile(object));
      }
      return children;
    }
  }

  /** A class that mimics a tiny subset of the JBoss VFS class. */
  static class VFS {
    static Class<?> VFS;
    static Method getChild;

    private VFS() {
      // Prevent Instantiation
    }

    static VirtualFile getChild(URL url) throws IOException {
      Object o = invoke(getChild, VFS, url);
      return o == null ? null : new VirtualFile(o);
    }
  }

  /** Flag that indicates if this VFS is valid for the current environment. */
  private static Boolean valid;

  /** Find all the classes and methods that are required to access the JBoss 6 VFS. */
  protected static synchronized void initialize() {
    if (valid == null) {
      // Assume valid. It will get flipped later if something goes wrong.
      valid = Boolean.TRUE;

      // Look up and verify required classes
      VFS.VFS = checkNotNull(getClass("org.jboss.vfs.VFS"));
      VirtualFile.VirtualFile = checkNotNull(getClass("org.jboss.vfs.VirtualFile"));

      // Look up and verify required methods
      VFS.getChild = checkNotNull(getMethod(VFS.VFS, "getChild", URL.class));
      VirtualFile.getChildrenRecursively = checkNotNull(getMethod(VirtualFile.VirtualFile, "getChildrenRecursively"));
      VirtualFile.getPathNameRelativeTo = checkNotNull(
          getMethod(VirtualFile.VirtualFile, "getPathNameRelativeTo", VirtualFile.VirtualFile));

      // Verify that the API has not changed
      checkReturnType(VFS.getChild, VirtualFile.VirtualFile);
      checkReturnType(VirtualFile.getChildrenRecursively, List.class);
      checkReturnType(VirtualFile.getPathNameRelativeTo, String.class);
    }
  }

  /**
   * Verifies that the provided object reference is null. If it is null, then this VFS is marked as invalid for the
   * current environment.
   *
   * @param <T>
   *          the generic type
   * @param object
   *          The object reference to check for null.
   *
   * @return the t
   */
  protected static <T> T checkNotNull(T object) {
    if (object == null) {
      setInvalid();
    }
    return object;
  }

  /**
   * Verifies that the return type of method is what it is expected to be. If it is not, then this VFS is marked as
   * invalid for the current environment.
   *
   * @param method
   *          The method whose return type is to be checked.
   * @param expected
   *          A type to which the method's return type must be assignable.
   *
   * @see Class#isAssignableFrom(Class)
   */
  protected static void checkReturnType(Method method, Class<?> expected) {
    if (method != null && !expected.isAssignableFrom(method.getReturnType())) {
      log.log(Level.SEVERE, "Method " + method.getClass().getName() + "." + method.getName() + "(..) should return "
          + expected.getName() + " but returns " + method.getReturnType().getName() + " instead.");
      setInvalid();
    }
  }

  /**
   * Mark this {@link VFS} as invalid for the current environment.
   */
  protected static void setInvalid() {
    if (JBoss6VFS.valid.booleanValue()) {
      log.log(Level.FINER, "JBoss 6 VFS API is not available in this environment.");
      JBoss6VFS.valid = Boolean.FALSE;
    }
  }

  static {
    initialize();
  }

  @Override
  public boolean isValid() {
    return valid;
  }

  @Override
  public List<String> list(URL url, String path) throws IOException {
    VirtualFile directory;
    directory = VFS.getChild(url);
    if (directory == null) {
      return List.of();
    }

    if (!path.endsWith("/")) {
      path += "/";
    }

    List<VirtualFile> children = directory.getChildren();
    List<String> names = new ArrayList<>(children.size());
    for (VirtualFile vf : children) {
      names.add(path + vf.getPathNameRelativeTo(directory));
    }

    return names;
  }
}

1	/*
2	* Copyright 2010-2026 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.apache.ibatis.migration.io;
17
18	import java.io.IOException;
19	import java.lang.reflect.Method;
20	import java.net.URL;
21	import java.util.ArrayList;
22	import java.util.List;
23	import java.util.logging.Level;
24	import java.util.logging.Logger;
25
26	/**
27	* A {@link VFS} implementation that works with the VFS API provided by JBoss 6.
28	*/
29	public class JBoss6VFS extends VFS {	1✔
30	private static final Logger log = Logger.getLogger(JBoss6VFS.class.getName());	1✔
31
32	/** A class that mimics a tiny subset of the JBoss VirtualFile class. */
33	static class VirtualFile {
34	static Class<?> VirtualFile;
35	static Method getPathNameRelativeTo;
36	static Method getChildrenRecursively;
37
38	Object virtualFile;
39
40	VirtualFile(Object virtualFile) {	×
41	this.virtualFile = virtualFile;	×
42	}	×
43
44	String getPathNameRelativeTo(VirtualFile parent) {
45	try {
46	return invoke(getPathNameRelativeTo, virtualFile, parent.virtualFile);	×
47	} catch (IOException e) {	×
48	// This exception is not thrown by the called method
49	log.log(Level.SEVERE, "This should not be possible. VirtualFile.getPathNameRelativeTo() threw IOException.");	×
50	return null;	×
51	}
52	}
53
54	List<VirtualFile> getChildren() throws IOException {
55	List<?> objects = invoke(getChildrenRecursively, virtualFile);	×
56	List<VirtualFile> children = new ArrayList<>(objects.size());	×
57	for (Object object : objects) {	×
58	children.add(new VirtualFile(object));	×
59	}	×
60	return children;	×
61	}
62	}
63
64	/** A class that mimics a tiny subset of the JBoss VFS class. */
65	static class VFS {
66	static Class<?> VFS;
67	static Method getChild;
68
69	private VFS() {
70	// Prevent Instantiation
71	}
72
73	static VirtualFile getChild(URL url) throws IOException {
74	Object o = invoke(getChild, VFS, url);	×
75	return o == null ? null : new VirtualFile(o);	×
76	}
77	}
78
79	/** Flag that indicates if this VFS is valid for the current environment. */
80	private static Boolean valid;
81
82	/** Find all the classes and methods that are required to access the JBoss 6 VFS. */
83	protected static synchronized void initialize() {
84	if (valid == null) {	1!
85	// Assume valid. It will get flipped later if something goes wrong.
86	valid = Boolean.TRUE;	1✔
87
88	// Look up and verify required classes
89	VFS.VFS = checkNotNull(getClass("org.jboss.vfs.VFS"));	1✔
90	VirtualFile.VirtualFile = checkNotNull(getClass("org.jboss.vfs.VirtualFile"));	1✔
91
92	// Look up and verify required methods
93	VFS.getChild = checkNotNull(getMethod(VFS.VFS, "getChild", URL.class));	1✔
94	VirtualFile.getChildrenRecursively = checkNotNull(getMethod(VirtualFile.VirtualFile, "getChildrenRecursively"));	1✔
95	VirtualFile.getPathNameRelativeTo = checkNotNull(	1✔
96	getMethod(VirtualFile.VirtualFile, "getPathNameRelativeTo", VirtualFile.VirtualFile));	1✔
97
98	// Verify that the API has not changed
99	checkReturnType(VFS.getChild, VirtualFile.VirtualFile);	1✔
100	checkReturnType(VirtualFile.getChildrenRecursively, List.class);	1✔
101	checkReturnType(VirtualFile.getPathNameRelativeTo, String.class);	1✔
102	}
103	}	1✔
104
105	/**
106	* Verifies that the provided object reference is null. If it is null, then this VFS is marked as invalid for the
107	* current environment.
108	*
109	* @param <T>
110	* the generic type
111	* @param object
112	* The object reference to check for null.
113	*
114	* @return the t
115	*/
116	protected static <T> T checkNotNull(T object) {
117	if (object == null) {	1!
118	setInvalid();	1✔
119	}
120	return object;	1✔
121	}
122
123	/**
124	* Verifies that the return type of method is what it is expected to be. If it is not, then this VFS is marked as
125	* invalid for the current environment.
126	*
127	* @param method
128	* The method whose return type is to be checked.
129	* @param expected
130	* A type to which the method's return type must be assignable.
131	*
132	* @see Class#isAssignableFrom(Class)
133	*/
134	protected static void checkReturnType(Method method, Class<?> expected) {
135	if (method != null && !expected.isAssignableFrom(method.getReturnType())) {	1!
136	log.log(Level.SEVERE, "Method " + method.getClass().getName() + "." + method.getName() + "(..) should return "	×
137	+ expected.getName() + " but returns " + method.getReturnType().getName() + " instead.");	×
138	setInvalid();	×
139	}
140	}	1✔
141
142	/**
143	* Mark this {@link VFS} as invalid for the current environment.
144	*/
145	protected static void setInvalid() {
146	if (JBoss6VFS.valid.booleanValue()) {	1✔
147	log.log(Level.FINER, "JBoss 6 VFS API is not available in this environment.");	1✔
148	JBoss6VFS.valid = Boolean.FALSE;	1✔
149	}
150	}	1✔
151
152	static {
153	initialize();	1✔
154	}	1✔
155
156	@Override
157	public boolean isValid() {
158	return valid;	1✔
159	}
160
161	@Override
162	public List<String> list(URL url, String path) throws IOException {
163	VirtualFile directory;
164	directory = VFS.getChild(url);	×
165	if (directory == null) {	×
NEW 166	return List.of();	×
167	}
168
169	if (!path.endsWith("/")) {	×
170	path += "/";	×
171	}
172
173	List<VirtualFile> children = directory.getChildren();	×
174	List<String> names = new ArrayList<>(children.size());	×
175	for (VirtualFile vf : children) {	×
176	names.add(path + vf.getPathNameRelativeTo(directory));	×
177	}	×
178
179	return names;	×
180	}
181	}

mybatis / migrations / 1057

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous