private void checkCommands(final String os, final String... command) throws ReflectiveOperationException { final URL[] urLs = ((URLClassLoader) Main.class.getClassLoader()).getURLs(); ThreadClassLoaderScope scope = null; try { System.setProperty("os.name", os); final URLClassLoader urlClassLoader = new URLClassLoader(urLs, null); scope = new ThreadClassLoaderScope(urlClassLoader); final Object terra = urlClassLoader.loadClass("org.ligoj.app.plugin.prov.terraform.TerraformUtils").newInstance(); final Object mock = MethodUtils.invokeStaticMethod(urlClassLoader.loadClass("org.mockito.Mockito"), "mock", urlClassLoader.loadClass("org.ligoj.bootstrap.resource.system.configuration.ConfigurationResource")); FieldUtils.writeField(terra, "configuration", mock, true); Assert.assertEquals(Arrays.asList(command), ((ProcessBuilder) MethodUtils.invokeMethod(terra, true, "newBuilder", new Object[] { new String[] { "terraform" } })) .command()); } finally { IOUtils.closeQuietly(scope); } }
@Override public LibraryResolver getLibraryResolver(Object realm) { if (!(realm instanceof Plugin)) throw new IllegalArgumentException("Only realms of type " + Plugin.class.getName() + " are supported"); Plugin plugin = (Plugin) realm; String name = plugin.getDescription().getName(); ClassLoader classLoader = realm.getClass().getClassLoader(); if (!(classLoader instanceof URLClassLoader)) throw new UnsupportedOperationException("Plugin " + name + " was not loaded by a URLClassLoader"); return libraryResolvers.computeIfAbsent(name, n -> new ClassLoaderLibraryResolver( repositorySystem, createSession(), remoteRepositorySupplier, (URLClassLoader) classLoader, plugin.getLogger() )); }
@CheckForNull public static Path getJRTFS() throws IOException { final File java9 = getJava9Home(); if (java9 == null) { return null; } final File jrtFsProvider = new File(java9,"jrt-fs.jar"); //NOI18N if (jrtFsProvider.exists() && jrtFsProvider.isFile() && jrtFsProvider.canRead()) { final ClassLoader cl = new URLClassLoader(new URL[]{ BaseUtilities.toURI(jrtFsProvider).toURL() }); final ServiceLoader<FileSystemProvider> sl = ServiceLoader.load(FileSystemProvider.class, cl); FileSystemProvider jrtp = null; for (FileSystemProvider fsp : sl) { if ("jrt".equals(fsp.getScheme())) { //NOI18N jrtp = fsp; break; } } if (jrtp != null) { return jrtp.getPath(URI.create("jrt:/")); //NOI18N } } return null; }
@Override public void run() { try { URL u = this.getClass().getClassLoader().getResource("DummyClass.class"); String path = u.getPath(); String parent = u.getPath().substring(0, path.lastIndexOf('/')+1); URL parentURL = new URL(u, parent); System.out.println(parentURL); /* Load lots of class by creating multiple classloaders */ for(;;) { ClassLoader cl = new URLClassLoader(new URL[] {parentURL}, null); cl.loadClass("DummyClass"); } } catch (Exception e) { e.printStackTrace(); } }
/** * Given a path with a jar, make a classloader with that jar on the * classpath, and check that findContainingJar can correctly * identify the path of the jar. */ private void testJarAtPath(String path) throws Exception { File jar = new File(path).getAbsoluteFile(); assertTrue(jar.exists()); URL urls[] = new URL[] { jar.toURI().toURL() }; ClassLoader cl = new URLClassLoader(urls); Class clazz = Class.forName(CLASSNAME, true, cl); assertNotNull(clazz); String containingJar = ClassUtil.findContainingJar(clazz); assertEquals(jar.getAbsolutePath(), containingJar); }
/** This method is called before the actual test method to allow * the benchmark to prepare accordingly to informations available * through {@link #getIterationCount}, {@link #getArgument} and {@link #getName}. * This method can use assertions to signal failure of the test. * @throws Exception This method can throw any exception which is treated as a error in the testing code * or testing enviroment. */ protected void setUp() throws Exception { int size = getIntValue(CLASS_NO_KEY); FileObject[] fileObjects = mfstest.setUpFileObjects(size); FileWrapper[] wrappers = mfstest.getFileWrappers(); URLClassLoader[] parents = new URLClassLoader[wrappers.length]; for (int i = 0; i < parents.length; i++) { parents[i] = new URLClassLoader(new URL[] { wrappers[i].getMnt().toURL() }); } // MultiURLClassLoader multicloader = new MultiURLClassLoader(new URL[] {}, parents); ClassLoader multicloader = new ProxyClassLoader(parents); instanceObjects = fileObjects2InstanceDataObjects(fileObjects); setClassLoader(instanceObjects, multicloader); }
public JdkCompiler(){ options = new ArrayList<String>(); options.add("-target"); options.add("1.6"); StandardJavaFileManager manager = compiler.getStandardFileManager(diagnosticCollector, null, null); final ClassLoader loader = Thread.currentThread().getContextClassLoader(); if (loader instanceof URLClassLoader && (! loader.getClass().getName().equals("sun.misc.Launcher$AppClassLoader"))) { try { URLClassLoader urlClassLoader = (URLClassLoader) loader; List<File> files = new ArrayList<File>(); for (URL url : urlClassLoader.getURLs()) { files.add(new File(url.getFile())); } manager.setLocation(StandardLocation.CLASS_PATH, files); } catch (IOException e) { throw new IllegalStateException(e.getMessage(), e); } } classLoader = AccessController.doPrivileged(new PrivilegedAction<ClassLoaderImpl>() { public ClassLoaderImpl run() { return new ClassLoaderImpl(loader); } }); javaFileManager = new JavaFileManagerImpl(manager, classLoader); }
@Test public void test_should_load_testng_version() throws MalformedURLException { // given File junitFile = Maven .resolver() .resolve("org.testng:testng:" + testNgVersion) .withoutTransitivity() .asSingleFile(); URL[] junitUrl = {junitFile.toURI().toURL()}; URLClassLoader urlClassLoader = new URLClassLoader(junitUrl); // when String junitVersion = LoaderVersionExtractor.getVersionFromClassLoader(LoaderVersionExtractor.LIBRARY_TEST_NG, urlClassLoader); // then assertThat(junitVersion).isEqualTo(testNgVersion); }
public static ClassLoader classLoader(ClassLoader parent, List<File> locations) { URL[] urls = new URL[locations.size()]; for (int i = 0; i < locations.size(); i++) { File location = locations.get(i); URL asUrl = fileToUrl(location); // TODO own type so we don't need to slash back and forth asUrl = withTrailingSlashIfDir(asUrl); urls[i] = asUrl; } if (parent != null) { return new URLClassLoader(urls, parent); } else { return new URLClassLoader(urls); } }
private static WeakReference<ClassLoader> testShadow(Class<?> originalTestClass) throws Exception { String[] cpaths = System.getProperty("test.classes", ".") .split(File.pathSeparator); URL[] urls = new URL[cpaths.length]; for (int i=0; i < cpaths.length; i++) { urls[i] = Paths.get(cpaths[i]).toUri().toURL(); } URLClassLoader shadowLoader = new ShadowClassLoader(urls, originalTestClass.getClassLoader().getParent()); System.out.println("Shadow loader is " + shadowLoader); String className = originalTestClass.getName(); Class<?> testClass = Class.forName(className, false, shadowLoader); if (testClass.getClassLoader() != shadowLoader) { throw new IllegalArgumentException("Loader didn't work: " + testClass.getClassLoader() + " != " + shadowLoader); } Method main = testClass.getMethod("main", String[].class); main.invoke(null, (Object) new String[0]); return new WeakReference<ClassLoader>(shadowLoader); }
@Test public void toFile() throws IOException { ThreadClassLoaderScope scope = null; try { final PluginsClassLoader classLoader = Mockito.mock(PluginsClassLoader.class); scope = new ThreadClassLoaderScope(new URLClassLoader(new URL[0], classLoader)); final File file = new File(""); final Subscription entity = new Subscription(); entity.setId(15); Mockito.when(classLoader.toFile(entity, "15", "some")).thenReturn(file); Assert.assertSame(file, resource.toFile(entity, "some")); Assert.assertNotNull(PluginsClassLoader.getInstance()); } finally { IOUtils.closeQuietly(scope); } }
private static void addURLs(URL[] jars) throws Exception { URLClassLoader loader = (URLClassLoader)Thread.currentThread().getContextClassLoader(); //bypass protected access. Method addURL = URLClassLoader.class.getDeclaredMethod("addURL", new Class[] { URL.class }); addURL.setAccessible(true); //pound sand. for (int i=0; i<jars.length; i++) { addURL.invoke(loader, new Object[] { jars[i] }); } }
public static void main(String[] args) throws Exception { URLConnection conn = B7050028.class.getResource("B7050028.class").openConnection(); int len = conn.getContentLength(); byte[] data = new byte[len]; InputStream is = conn.getInputStream(); is.read(data); is.close(); conn.setDefaultUseCaches(false); File jar = File.createTempFile("B7050028", ".jar"); jar.deleteOnExit(); OutputStream os = new FileOutputStream(jar); ZipOutputStream zos = new ZipOutputStream(os); ZipEntry ze = new ZipEntry("B7050028.class"); ze.setMethod(ZipEntry.STORED); ze.setSize(len); CRC32 crc = new CRC32(); crc.update(data); ze.setCrc(crc.getValue()); zos.putNextEntry(ze); zos.write(data, 0, len); zos.closeEntry(); zos.finish(); zos.close(); os.close(); System.out.println(new URLClassLoader(new URL[] {new URL("jar:" + jar.toURI() + "!/")}, ClassLoader.getSystemClassLoader().getParent()).loadClass(B7050028.class.getName())); }
/** * 加载对应路径jar包里的对应驱动 * * @param fname 对应路径 如: lib4/ojdbc14.jar * @param dname 驱动名 如: oracle.jdbc.driver.OracleDriver * @return 加载到的驱动 java.sql.Driver * @throws Exception * @author tangxr */ public static Driver getDriverLoaderByName(String fname, String dname) throws Exception { if (null == fname || "".equals(fname)) { LOG.error("对应的驱动路径不存在,请确认."); return null; } if (null == dname || "".equals(dname)) { LOG.error("对应的驱动类的名字不存在."); return null; } File file = new File(fname); if (!file.exists()) { LOG.error("对应的驱动jar不存在."); return null; } URLClassLoader loader = new URLClassLoader(new URL[]{file.toURI().toURL()}); loader.clearAssertionStatus(); return (Driver) loader.loadClass(dname).newInstance(); }
@Test @Ignore("Causes problems with gradle test invocation") public void testCompilation() throws ClassNotFoundException, IllegalAccessException, InstantiationException { List<IDirectory> sourcePath = new ArrayList<>( ManifoldHost.getGlobalModule().getSourcePath() ); sourcePath.add( ManifoldHost.getFileSystem().getIDirectory( JavacTask.class.getProtectionDomain().getCodeSource().getLocation() ) ); ClassLoader cl = new URLClassLoader( sourcePath.stream().map( e -> { try { return e.toURI().toURL(); } catch( MalformedURLException e1 ) { throw new RuntimeException( e1 ); } } ).toArray( URL[]::new ), null ); Class<?> cls = Class.forName( Tests.class.getName(), true, cl ); cls.newInstance(); }
public String getDebugMsg() { if (debugMsg == null) { debugMsg = "Can not find entry " + key + " in resource file " + resource + " for the locale " + locale + "."; if (loader instanceof URLClassLoader) { URL[] urls = ((URLClassLoader) loader).getURLs(); debugMsg += " The following entries in the classpath were searched: "; for (int i = 0; i != urls.length; i++) { debugMsg += urls[i] + " "; } } } return debugMsg; }
public static void main(String args[]) throws Exception { // create files from given arguments and tools.jar File f1 = new File(args[0]); String home = System.getProperty("java.home"); String tools = ".." + File.separatorChar + "lib" + File.separatorChar + "tools.jar"; File f2 = (new File(home, tools)).getCanonicalFile(); // create class loader URL[] urls = { f1.toURL(), f2.toURL() }; URLClassLoader cl = new URLClassLoader(urls); // load ListConnectors using the class loader // and then invoke the list method. Class c = Class.forName("ListConnectors", true, cl); Method m = c.getDeclaredMethod("list"); Object o = c.newInstance(); m.invoke(o); }
public void testGetClasspathComponentsFromClassLoader() throws MalformedURLException { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); try { File file = new File("/some/package/dir"); URL[] urls = new URL[] { file.toURL() }; // assert my package can't be found yet List components = ClasspathUtils.getClasspathComponents(); Collections.sort(components); assertTrue(Collections.binarySearch(components, file.getPath()) < 0); // test my package is found URLClassLoader ucl = new URLClassLoader(urls, classLoader); Thread.currentThread().setContextClassLoader(ucl); components = ClasspathUtils.getClasspathComponents(); Collections.sort(components); assertTrue( Collections.binarySearch(components, file.getAbsolutePath()) >= 0); } finally { Thread.currentThread().setContextClassLoader(classLoader); } }
static PermissionCollection getRestrictedPermissions() { Permissions perms = new Permissions(); // property/env access needed for parsing perms.add(new PropertyPermission("*", "read")); perms.add(new RuntimePermission("getenv.TIKA_CONFIG")); // add permissions for resource access: // classpath addReadPermissions(perms, JarHell.parseClassPath()); // plugin jars if (TikaImpl.class.getClassLoader() instanceof URLClassLoader) { addReadPermissions(perms, ((URLClassLoader)TikaImpl.class.getClassLoader()).getURLs()); } // jvm's java.io.tmpdir (needs read/write) perms.add(new FilePermission(System.getProperty("java.io.tmpdir") + System.getProperty("file.separator") + "-", "read,readlink,write,delete")); // current hacks needed for POI/PDFbox issues: perms.add(new SecurityPermission("putProviderProperty.BC")); perms.add(new SecurityPermission("insertProvider")); perms.add(new ReflectPermission("suppressAccessChecks")); // xmlbeans, use by POI, needs to get the context classloader perms.add(new RuntimePermission("getClassLoader")); perms.setReadOnly(); return perms; }
private static void getClassNameFromClsLoader(List<String> fileNames, boolean childPackage, String packagePath, URL url, ClassLoader cl) { List<String> tempFileNames = null; if (url != null) { String type = url.getProtocol(); if ("file".equals(type)) { tempFileNames = getClassNameByFile(url.getPath(), childPackage); } else if ("jar".equals(type)) { tempFileNames = getClassNameByJar(url.getPath(), childPackage); } } else { tempFileNames = getClassNameByJars(((URLClassLoader) cl).getURLs(), packagePath, childPackage); } if (tempFileNames != null) { fileNames.addAll(tempFileNames); } }
/** * @param className A non-null fully qualified class name. * @param codebase A non-null, space-separated list of URL strings. */ public Class<?> loadClass(String className, String codebase) throws ClassNotFoundException, MalformedURLException { ClassLoader parent = getContextClassLoader(); ClassLoader cl = URLClassLoader.newInstance(getUrlArray(codebase), parent); return loadClass(className, cl); }
public static String test(int i) throws ClassNotFoundException { final URLClassLoader classLoader = new URLClassLoader(new URL[0], String.class.getClassLoader()); if (i == 0) { return classLoader.loadClass("java.lang.String").toString(); } else if (i == 1) { return classLoader.loadClass("[Ljava.lang.String;").toString(); } else if (i == 2) { return classLoader.loadClass("java.lang.String[]").toString(); } return null; }
private static String pluginClasspath() { URLClassLoader classloader = (URLClassLoader) ClassLoader.getSystemClassLoader(); List<String> classpath = new ArrayList<>(); for (URL url : classloader.getURLs()) { classpath.add(url.getFile()); } return Joiner.on(':').join(classpath); }
/** * 获取源码目录下指定包下的类 * @param root * @param pkg * @return * @throws Exception */ public List<Class<?>> getClassInfo(String root,String pkg) throws Exception { List<Class<?>> list=new ArrayList<Class<?>>(); String suffix=".java"; File rootDir=new File(root); Set<File> files=FileUtil.findFileByDirAndSub(rootDir,suffix); URLClassLoader loader=new URLClassLoader(new URL[]{rootDir.toURI().toURL()}); try { // 获取路径长度 int clazzPathLen = rootDir.getAbsolutePath().length() + 1; for(File file:files) { String className = file.getAbsolutePath(); className = className.substring(clazzPathLen, className.length() - suffix.length()); className = className.replace(File.separatorChar, '.'); try { Class<?> clazz=loader.loadClass(className); String pkgName=clazz.getPackage().getName(); if(pkgName.equals(pkg)) { list.add(clazz); } } catch (Exception e) { } } } finally { loader.close(); } return list; }
@AndroidIncompatible // Android forbids null parent ClassLoader // https://github.com/google/guava/issues/2152 public void testClassPathEntries_URLClassLoader_pathWithSpace() throws Exception { URL url = new URL("file:///c:/Documents and Settings/"); URLClassLoader classloader = new URLClassLoader(new URL[] {url}, null); assertThat(ClassPath.Scanner.getClassPathEntries(classloader)) .containsExactly(new File("/c:/Documents and Settings/"), classloader); }
public static ClojureRuntime get() { String[] classpathElements = System.getProperty("shim.classpath").split(File.pathSeparator); URL[] classpathUrls = Arrays.stream(classpathElements) .map(Paths::get) .map(Path::toUri) .map(safe(URI::toURL)) .toArray(size -> new URL[size]); URLClassLoader loader = new ClojureWorkerClassLoader(classpathUrls, ClojureWorker.class.getClassLoader()); ClojureRuntimeShim shim = ClojureRuntimeShim.newRuntime(loader, "gradle-clojure"); return new ClojureRuntime(loader, shim); }
/** * Returns a module extracted from a jar file. * @param path the filename of the module * @return a module * @throws Exception if something goes wrong, an exception is thrown */ public Module getModuleFromJar(String path) throws Exception { Module m = null; JarFile modFile = new JarFile(path); Manifest mf = modFile.getManifest(); Attributes attr = mf.getMainAttributes(); String mainClass = attr.getValue(Attributes.Name.MAIN_CLASS); URLClassLoader classLoader = new URLClassLoader(new URL[]{ new File(path).toURI().toURL() }); Class c = classLoader.loadClass(mainClass); Class[] interfaces = c.getInterfaces(); classLoader.close(); boolean isPlugin = false; for(int i = 0; i < interfaces.length && !isPlugin; i++) { if(interfaces[i].getName().equals("com.github.hydrazine.module.Module")) { isPlugin = true; } } if(isPlugin) { m = (Module) c.newInstance(); } else { System.out.println(Hydrazine.warnPrefix + "\"" + path + "\" isn't a valid module. You should remove it from the directory."); } modFile.close(); return m; }
public ClassProvider(String classpath) { try { ArrayList<URL> urls = new ArrayList<URL>(); for (String path : classpath.split(File.pathSeparator)) { urls.add(Paths.get(path).toFile().toURI().toURL()); } _classLoader = new URLClassLoader(urls.toArray(new URL[0]), getClass().getClassLoader()); } catch (Exception e) { throw new RuntimeException("Failed to create class loader"); } }
/** * Add a library URL. * * @param url URL to add. If this URL is already in the list, it is not added. * * @throws NullPointerException If <code>url</code> is <code>null</code>. */ public void addLibraryURL(URL url) throws NullPointerException { if (url == null) throw new NullPointerException("Cannot add library URL: null"); if (libraryUrlList.contains(url)) return; libraryUrlList.add(url); loader = new URLClassLoader(libraryUrlList.toArray(new URL[0])); return; }
/** Creates a class loader with the given base URL as its classpath. */ URLClassLoader newLoader(URL base) { // We use the bootstrap class loader as the parent because Finalizer by design uses // only standard Java classes. That also means that FinalizableReferenceQueueTest // doesn't pick up the wrong version of the Finalizer class. return new URLClassLoader(new URL[] {base}, null); }
private static ClassLoader loadJars(String[] jarFiles) { URL[] urls = Stream.of(jarFiles) .map(name -> { try { return new File(name).toURI().toURL(); } catch (MalformedURLException e) { System.out.println("Fail to load jar file: " + name); e.printStackTrace(); return null; } }) .toArray(URL[]::new); return URLClassLoader.newInstance(urls, ClassLoader.getSystemClassLoader()); }
private static void searchInCurrentClassLoaderIfUrlOne(List<String> prefixes, Set<ClassName> names) { ClassLoader loader = ClassScanner.class.getClassLoader(); while (loader != null) { if (loader instanceof URLClassLoader) { URLClassLoader urlLoader = (URLClassLoader) loader; for (URL url : urlLoader.getURLs()) { try { URI uri = url.toURI(); File file = new File(uri); String path = file.getAbsolutePath(); if(file.isDirectory()){ scanDirectory(prefixes, names, file, path); } else if(path.endsWith(".jar")){ scanJar(prefixes, names, path); } } catch (Exception e) { SimpleLogger.error("Error while parsing URL " + url); continue; } } } loader = loader.getParent(); } }
public static ClassLoader newClassLoader() { try { return new URLClassLoader(new URL[] { Paths.get(System.getProperty("test.classes",".") + File.separatorChar + "classes").toUri().toURL(), }, null); } catch (MalformedURLException e){ throw new RuntimeException("Unexpected URL conversion failure", e); } }
private static void loadJar(String jarFile) throws IOException { URLClassLoader sysloader = (URLClassLoader) ClassLoader.getSystemClassLoader(); Class<? extends URLClassLoader> sysclass = URLClassLoader.class; try { Method method = sysclass.getDeclaredMethod("addURL", URL.class); method.setAccessible(true); method.invoke(sysloader, new File(jarFile).toURI().toURL()); } catch (Throwable t) { throw new IOException("Error, could not add URL to system classloader", t); } }
/** * Lists (to System.out) the paths where classes are loaded from. */ public static void printClassPath() { ClassLoader cl = ClassLoader.getSystemClassLoader(); URL[] urls = ((URLClassLoader) cl).getURLs(); for (URL url : urls) { System.out.println(url.getPath()); } }
/** * Finds the <tt>META-INF/sun-jaxb.episode</tt> file to add as a binding customization. */ public void scanEpisodeFile(File jar) throws BadCommandLineException { try { URLClassLoader ucl = new URLClassLoader(new URL[]{jar.toURL()}); Enumeration<URL> resources = ucl.findResources("META-INF/sun-jaxb.episode"); while (resources.hasMoreElements()) { URL url = resources.nextElement(); addBindFile(new InputSource(url.toExternalForm())); } } catch (IOException e) { throw new BadCommandLineException( Messages.format(Messages.FAILED_TO_LOAD,jar,e.getMessage()), e); } }
private void listClasses(URLClassLoader loader) { URL[] urls = loader.getURLs(); for (final URL url : urls) { log.info("Listing classes for URL {}", url); listClasses(loader, url); } }
private static Processor createClassLoaderDelegate() { try { if (cachedProxyClassLoader == null) { cachedProxyClassLoader = new ProxyClassLoader( ((URLClassLoader) ProxyProcessor.class.getClassLoader()).getURLs(), Thread.currentThread().getContextClassLoader()); } return (Processor) cachedProxyClassLoader.loadClass(DELEGATE_CLASS).newInstance(); } catch (Throwable ex) { throw new RuntimeException(ex); } }
@Test public void test() throws Exception { URL url = new URL("file:E:/JavaJars/OtherJar/runner.jar"); URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{url}, Thread.currentThread().getContextClassLoader()); Class<?> clazz = urlClassLoader.loadClass("com.example.Runner"); //Runnable runnable = (Runnable) clazz.newInstance(); //runnable.run(); Method method = clazz.getMethod("run"); method.invoke(clazz.newInstance()); urlClassLoader.close(); }
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException { if (args.length != 1) { throw new Error("Test Bug: Expected class name wasn't provided as command line argument"); } G1SampleClass sampleClass = G1SampleClass.valueOf(args[0]); Path wrkDir = Files.createTempDirectory(Paths.get(""), CLASS_NAME_PREFIX); URL[] url = {wrkDir.toUri().toURL()}; URLClassLoader urlLoader = new URLClassLoader(url); Object sampleObject; try { sampleObject = sampleClass.getCls(urlLoader, wrkDir, CLASS_NAME_PREFIX).newInstance(); } catch (Throwable throwable) { throw new AssertionError("Test Bug: Cannot create object of provided class", throwable); } boolean isHumongous = WB.g1IsHumongous(sampleObject); boolean shouldBeHumongous = (sampleClass.expectedInstanceSize() > (WB.g1RegionSize() / 2)); // Sanity check Asserts.assertEquals(WB.getObjectSize(sampleObject), sampleClass.expectedInstanceSize(), String.format("Test Bug: Object of class %s is expected to take %d bytes but it takes %d.", sampleClass.name(), sampleClass.expectedInstanceSize(), WB.getObjectSize(sampleObject))); // Test check Asserts.assertEquals(isHumongous, shouldBeHumongous, String.format("Object of class %s is expected to be %shumongous but it is not", sampleClass.name(), (shouldBeHumongous ? "" : "non-"))); }