public static String getAccountsFile() {
final String path;
if (Configuration.getCurrentOperatingSystem() == OperatingSystem.WINDOWS) {
path = System.getenv("APPDATA") + File.separator + Configuration.NAME + "_Accounts.ini";
} else {
path = Paths.getUnixHome() + File.separator + "." + Configuration.NAME_LOWERCASE + "acct";
}
return path;
}
public static String getHomeDirectory() {
final String env = System.getenv(Configuration.NAME.toUpperCase() + "_HOME");
if (env == null || env.isEmpty()) {
return (Configuration.getCurrentOperatingSystem() == OperatingSystem.WINDOWS
? FileSystemView.getFileSystemView().getDefaultDirectory().getAbsolutePath()
: Paths.getUnixHome())
+ File.separator
+ Configuration.NAME;
} else {
return env;
}
}
private void browseAction() {
if (selectedPath == null) {
selectedPath = System.getenv("ROPE_SOURCES_DIR");
if (selectedPath != null) {
File dir = new File(selectedPath);
if (!dir.exists() || !dir.isDirectory()) {
String message =
String.format(
"The sources path set in environment variable ROPE_SOURCES_DIR is not avaliable.\n%s",
selectedPath);
JOptionPane.showMessageDialog(null, message, "ROPE", JOptionPane.WARNING_MESSAGE);
selectedPath = null;
} else {
System.out.println("Source folder path set from ROPE_SOURCES_DIR: " + selectedPath);
}
}
if (selectedPath == null) {
selectedPath = System.getProperty("user.dir");
System.out.println("Source folder path set to current directory: " + selectedPath);
}
}
Vector<RopeFileFilter> filters = new Vector<RopeFileFilter>();
filters.add(
new RopeFileFilter(
new String[] {".a", ".asm", ".aut", ".s"}, "Assembly files (*.a *.asm *.aut *.s)"));
filters.add(new RopeFileFilter(new String[] {".m", ".mac"}, "Macro files (*.m *.mac)"));
filters.add(new RopeFileFilter(new String[] {".lst"}, "List files (*.lst)"));
filters.add(new RopeFileFilter(new String[] {".txt"}, "Text files (*.txt)"));
RopeFileChooser chooser = new RopeFileChooser(selectedPath, null, filters);
chooser.setDialogTitle("Source document selection");
chooser.setFileFilter(filters.firstElement());
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
File file = chooser.open(this, fileText);
if (file != null) {
if (loadSourceFile(file)) {
mainFrame.showExecWindow(baseName);
}
}
}
boolean setHighscore() {
int high = 0;
boolean newh = false;
String path = "";
if (System.getProperty("os.name").toLowerCase().indexOf("mac") >= 0)
path =
new JFileChooser().getFileSystemView().getDefaultDirectory().toString()
+ "/Library/Application Support/ByRikard/IJAG";
else path = System.getenv("APPDATA") + "/ByRikard/IJAG";
String highscorePath = path + "/highscore";
try {
FileInputStream fstream = new FileInputStream(highscorePath);
DataInputStream in = new DataInputStream(fstream);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
high = Integer.parseInt(br.readLine());
in.close();
} catch (Exception e) {
}
oldHighScore = high;
if (high < player.score) {
high = player.score;
newh = true;
}
try {
String content = "" + high;
File file = new File(highscorePath);
if (!file.exists()) {
file.createNewFile();
}
FileWriter fw = new FileWriter(file.getAbsoluteFile());
BufferedWriter bw = new BufferedWriter(fw);
bw.write(content);
bw.close();
} catch (IOException e) {
}
return newh;
}
private void adjustConfiguration(Element root, File dir) {
// If this is an ISN installation and the Edge Server
// keystore and truststore files do not exist, then set the configuration
// to use the keystore.jks and truststore.jks files instead of the ones
// in the default installation. If the Edge Server files do exist, then
// delete the keystore.jks and truststore.jks files, just to avoid
// confusion.
if (programName.equals("ISN")) {
Element server = getFirstNamedChild(root, "Server");
Element ssl = getFirstNamedChild(server, "SSL");
String rsnaroot = System.getenv("RSNA_ROOT");
rsnaroot = (rsnaroot == null) ? "/usr/local/edgeserver" : rsnaroot.trim();
String keystore = rsnaroot + "/conf/keystore.jks";
String truststore = rsnaroot + "/conf/truststore.jks";
File keystoreFile = new File(keystore);
File truststoreFile = new File(truststore);
cp.appendln(Color.black, "Looking for " + keystore);
if (keystoreFile.exists() || truststoreFile.exists()) {
cp.appendln(Color.black, "...found it [This is an EdgeServer installation]");
// Delete the default files, just to avoid confusion
File ks = new File(dir, "keystore.jks");
File ts = new File(dir, "truststore.jks");
boolean ksok = ks.delete();
boolean tsok = ts.delete();
if (ksok && tsok) cp.appendln(Color.black, "...Unused default SSL files were removed");
else {
if (!ksok) cp.appendln(Color.black, "...Unable to delete " + ks);
if (!tsok) cp.appendln(Color.black, "...Unable to delete " + ts);
}
} else {
cp.appendln(Color.black, "...not found [OK, this is a non-EdgeServer installation]");
ssl.setAttribute("keystore", "keystore.jks");
ssl.setAttribute("keystorePassword", "edge1234");
ssl.setAttribute("truststore", "truststore.jks");
ssl.setAttribute("truststorePassword", "edge1234");
cp.appendln(
Color.black, "...SSL attributes were updated for a non-EdgeServer installation");
}
}
}
public static File getAppDir(String s) {
String s1 = System.getProperty("user.home", ".");
File file;
switch (EnumOSMappingHelper.enumOSMappingArray[getOs().ordinal()]) {
case 1: // '\001'
case 2: // '\002'
file = new File(s1, (new StringBuilder()).append('.').append(s).append('/').toString());
break;
case 3: // '\003'
String s2 = System.getenv("APPDATA");
if (s2 != null) {
file = new File(s2, (new StringBuilder()).append(".").append(s).append('/').toString());
} else {
file = new File(s1, (new StringBuilder()).append('.').append(s).append('/').toString());
}
break;
case 4: // '\004'
file =
new File(
s1,
(new StringBuilder()).append("Library/Application Support/").append(s).toString());
break;
default:
file = new File(s1, (new StringBuilder()).append(s).append('/').toString());
break;
}
if (!file.exists() && !file.mkdirs()) {
throw new RuntimeException(
(new StringBuilder())
.append("The working directory could not be created: ")
.append(file)
.toString());
} else {
return file;
}
}
/** @author peter */
@SuppressWarnings("UseOfSystemOutOrSystemErr")
public abstract class UsefulTestCase extends TestCase {
public static final boolean IS_UNDER_TEAMCITY = System.getenv("TEAMCITY_VERSION") != null;
public static final String IDEA_MARKER_CLASS =
"com.intellij.openapi.components.impl.stores.IdeaProjectStoreImpl";
public static final String TEMP_DIR_MARKER = "unitTest_";
protected static boolean OVERWRITE_TESTDATA = false;
private static final String DEFAULT_SETTINGS_EXTERNALIZED;
private static final Random RNG = new SecureRandom();
private static final String ORIGINAL_TEMP_DIR = FileUtil.getTempDirectory();
protected final Disposable myTestRootDisposable =
new Disposable() {
@Override
public void dispose() {}
@Override
public String toString() {
String testName = getTestName(false);
return UsefulTestCase.this.getClass()
+ (StringUtil.isEmpty(testName) ? "" : ".test" + testName);
}
};
protected static String ourPathToKeep = null;
private CodeStyleSettings myOldCodeStyleSettings;
private String myTempDir;
protected static final Key<String> CREATION_PLACE = Key.create("CREATION_PLACE");
static {
// Radar #5755208: Command line Java applications need a way to launch without a Dock icon.
System.setProperty("apple.awt.UIElement", "true");
try {
CodeInsightSettings defaultSettings = new CodeInsightSettings();
Element oldS = new Element("temp");
defaultSettings.writeExternal(oldS);
DEFAULT_SETTINGS_EXTERNALIZED = JDOMUtil.writeElement(oldS, "\n");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected boolean shouldContainTempFiles() {
return true;
}
@Override
protected void setUp() throws Exception {
super.setUp();
if (shouldContainTempFiles()) {
String testName = getTestName(true);
if (StringUtil.isEmptyOrSpaces(testName)) testName = "";
testName = new File(testName).getName(); // in case the test name contains file separators
myTempDir =
FileUtil.toSystemDependentName(
ORIGINAL_TEMP_DIR + "/" + TEMP_DIR_MARKER + testName + "_" + RNG.nextInt(1000));
FileUtil.resetCanonicalTempPathCache(myTempDir);
}
//noinspection AssignmentToStaticFieldFromInstanceMethod
DocumentImpl.CHECK_DOCUMENT_CONSISTENCY = !isPerformanceTest();
}
@Override
protected void tearDown() throws Exception {
try {
Disposer.dispose(myTestRootDisposable);
cleanupSwingDataStructures();
cleanupDeleteOnExitHookList();
} finally {
if (shouldContainTempFiles()) {
FileUtil.resetCanonicalTempPathCache(ORIGINAL_TEMP_DIR);
if (ourPathToKeep != null && FileUtil.isAncestor(myTempDir, ourPathToKeep, false)) {
File[] files = new File(myTempDir).listFiles();
if (files != null) {
for (File file : files) {
if (!FileUtil.pathsEqual(file.getPath(), ourPathToKeep)) {
FileUtil.delete(file);
}
}
}
} else {
FileUtil.delete(new File(myTempDir));
}
}
}
UIUtil.removeLeakingAppleListeners();
super.tearDown();
}
private static final Set<String> DELETE_ON_EXIT_HOOK_DOT_FILES;
private static final Class DELETE_ON_EXIT_HOOK_CLASS;
static {
Class<?> aClass = null;
Set<String> files = null;
try {
aClass = Class.forName("java.io.DeleteOnExitHook");
files = ReflectionUtil.getField(aClass, null, Set.class, "files");
} catch (Exception ignored) {
}
DELETE_ON_EXIT_HOOK_CLASS = aClass;
DELETE_ON_EXIT_HOOK_DOT_FILES = files;
}
public static void cleanupDeleteOnExitHookList()
throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
// try to reduce file set retained by java.io.DeleteOnExitHook
List<String> list;
synchronized (DELETE_ON_EXIT_HOOK_CLASS) {
if (DELETE_ON_EXIT_HOOK_DOT_FILES.isEmpty()) return;
list = new ArrayList<String>(DELETE_ON_EXIT_HOOK_DOT_FILES);
}
for (int i = list.size() - 1; i >= 0; i--) {
String path = list.get(i);
if (FileSystemUtil.getAttributes(path) == null || new File(path).delete()) {
synchronized (DELETE_ON_EXIT_HOOK_CLASS) {
DELETE_ON_EXIT_HOOK_DOT_FILES.remove(path);
}
}
}
}
private static void cleanupSwingDataStructures() throws Exception {
Class<?> aClass = Class.forName("javax.swing.KeyboardManager");
Method get = aClass.getMethod("getCurrentManager");
get.setAccessible(true);
Object manager = get.invoke(null);
{
Field mapF = aClass.getDeclaredField("componentKeyStrokeMap");
mapF.setAccessible(true);
Object map = mapF.get(manager);
((Map) map).clear();
}
{
Field mapF = aClass.getDeclaredField("containerMap");
mapF.setAccessible(true);
Object map = mapF.get(manager);
((Map) map).clear();
}
}
protected CompositeException checkForSettingsDamage() throws Exception {
Application app = ApplicationManager.getApplication();
if (isPerformanceTest() || app == null || app instanceof MockApplication) {
return new CompositeException();
}
CodeStyleSettings oldCodeStyleSettings = myOldCodeStyleSettings;
myOldCodeStyleSettings = null;
return doCheckForSettingsDamage(oldCodeStyleSettings, getCurrentCodeStyleSettings());
}
public static CompositeException doCheckForSettingsDamage(
@NotNull CodeStyleSettings oldCodeStyleSettings,
@NotNull CodeStyleSettings currentCodeStyleSettings)
throws Exception {
CompositeException result = new CompositeException();
final CodeInsightSettings settings = CodeInsightSettings.getInstance();
try {
Element newS = new Element("temp");
settings.writeExternal(newS);
Assert.assertEquals(
"Code insight settings damaged",
DEFAULT_SETTINGS_EXTERNALIZED,
JDOMUtil.writeElement(newS, "\n"));
} catch (AssertionError error) {
CodeInsightSettings clean = new CodeInsightSettings();
Element temp = new Element("temp");
clean.writeExternal(temp);
settings.loadState(temp);
result.add(error);
}
currentCodeStyleSettings.getIndentOptions(StdFileTypes.JAVA);
try {
checkSettingsEqual(
oldCodeStyleSettings, currentCodeStyleSettings, "Code style settings damaged");
} catch (AssertionError e) {
result.add(e);
} finally {
currentCodeStyleSettings.clearCodeStyleSettings();
}
try {
InplaceRefactoring.checkCleared();
} catch (AssertionError e) {
result.add(e);
}
try {
StartMarkAction.checkCleared();
} catch (AssertionError e) {
result.add(e);
}
return result;
}
protected void storeSettings() {
if (!isPerformanceTest() && ApplicationManager.getApplication() != null) {
myOldCodeStyleSettings = getCurrentCodeStyleSettings().clone();
myOldCodeStyleSettings.getIndentOptions(StdFileTypes.JAVA);
}
}
protected CodeStyleSettings getCurrentCodeStyleSettings() {
if (CodeStyleSchemes.getInstance().getCurrentScheme() == null) return new CodeStyleSettings();
return CodeStyleSettingsManager.getInstance().getCurrentSettings();
}
public Disposable getTestRootDisposable() {
return myTestRootDisposable;
}
@Override
protected void runTest() throws Throwable {
final Throwable[] throwables = new Throwable[1];
Runnable runnable =
new Runnable() {
@Override
public void run() {
try {
UsefulTestCase.super.runTest();
} catch (InvocationTargetException e) {
e.fillInStackTrace();
throwables[0] = e.getTargetException();
} catch (IllegalAccessException e) {
e.fillInStackTrace();
throwables[0] = e;
} catch (Throwable e) {
throwables[0] = e;
}
}
};
invokeTestRunnable(runnable);
if (throwables[0] != null) {
throw throwables[0];
}
}
protected boolean shouldRunTest() {
return PlatformTestUtil.canRunTest(getClass());
}
public static void edt(Runnable r) {
UIUtil.invokeAndWaitIfNeeded(r);
}
protected void invokeTestRunnable(@NotNull Runnable runnable) throws Exception {
UIUtil.invokeAndWaitIfNeeded(runnable);
// runnable.run();
}
protected void defaultRunBare() throws Throwable {
super.runBare();
}
@Override
public void runBare() throws Throwable {
if (!shouldRunTest()) return;
if (runInDispatchThread()) {
final Throwable[] exception = {null};
UIUtil.invokeAndWaitIfNeeded(
new Runnable() {
@Override
public void run() {
try {
defaultRunBare();
} catch (Throwable tearingDown) {
if (exception[0] == null) exception[0] = tearingDown;
}
}
});
if (exception[0] != null) throw exception[0];
} else {
defaultRunBare();
}
}
protected boolean runInDispatchThread() {
return true;
}
@NonNls
public static String toString(Iterable<?> collection) {
if (!collection.iterator().hasNext()) {
return "<empty>";
}
final StringBuilder builder = new StringBuilder();
for (final Object o : collection) {
if (o instanceof THashSet) {
builder.append(new TreeSet<Object>((THashSet) o));
} else {
builder.append(o);
}
builder.append("\n");
}
return builder.toString();
}
public static <T> void assertOrderedEquals(T[] actual, T... expected) {
assertOrderedEquals(Arrays.asList(actual), expected);
}
public static <T> void assertOrderedEquals(Iterable<T> actual, T... expected) {
assertOrderedEquals(null, actual, expected);
}
public static void assertOrderedEquals(@NotNull byte[] actual, @NotNull byte[] expected) {
assertEquals(actual.length, expected.length);
for (int i = 0; i < actual.length; i++) {
byte a = actual[i];
byte e = expected[i];
assertEquals("not equals at index: " + i, e, a);
}
}
public static <T> void assertOrderedEquals(
final String errorMsg, @NotNull Iterable<T> actual, @NotNull T... expected) {
Assert.assertNotNull(actual);
Assert.assertNotNull(expected);
assertOrderedEquals(errorMsg, actual, Arrays.asList(expected));
}
public static <T> void assertOrderedEquals(
final Iterable<? extends T> actual, final Collection<? extends T> expected) {
assertOrderedEquals(null, actual, expected);
}
public static <T> void assertOrderedEquals(
final String erroMsg,
final Iterable<? extends T> actual,
final Collection<? extends T> expected) {
ArrayList<T> list = new ArrayList<T>();
for (T t : actual) {
list.add(t);
}
if (!list.equals(new ArrayList<T>(expected))) {
String expectedString = toString(expected);
String actualString = toString(actual);
Assert.assertEquals(erroMsg, expectedString, actualString);
Assert.fail(
"Warning! 'toString' does not reflect the difference.\nExpected: "
+ expectedString
+ "\nActual: "
+ actualString);
}
}
public static <T> void assertOrderedCollection(T[] collection, @NotNull Consumer<T>... checkers) {
Assert.assertNotNull(collection);
assertOrderedCollection(Arrays.asList(collection), checkers);
}
public static <T> void assertSameElements(T[] collection, T... expected) {
assertSameElements(Arrays.asList(collection), expected);
}
public static <T> void assertSameElements(Collection<? extends T> collection, T... expected) {
assertSameElements(collection, Arrays.asList(expected));
}
public static <T> void assertSameElements(
Collection<? extends T> collection, Collection<T> expected) {
assertSameElements(null, collection, expected);
}
public static <T> void assertSameElements(
String message, Collection<? extends T> collection, Collection<T> expected) {
assertNotNull(collection);
assertNotNull(expected);
if (collection.size() != expected.size()
|| !new HashSet<T>(expected).equals(new HashSet<T>(collection))) {
Assert.assertEquals(message, toString(expected, "\n"), toString(collection, "\n"));
Assert.assertEquals(message, new HashSet<T>(expected), new HashSet<T>(collection));
}
}
public <T> void assertContainsOrdered(Collection<? extends T> collection, T... expected) {
assertContainsOrdered(collection, Arrays.asList(expected));
}
public <T> void assertContainsOrdered(
Collection<? extends T> collection, Collection<T> expected) {
ArrayList<T> copy = new ArrayList<T>(collection);
copy.retainAll(expected);
assertOrderedEquals(toString(collection), copy, expected);
}
public <T> void assertContainsElements(Collection<? extends T> collection, T... expected) {
assertContainsElements(collection, Arrays.asList(expected));
}
public <T> void assertContainsElements(
Collection<? extends T> collection, Collection<T> expected) {
ArrayList<T> copy = new ArrayList<T>(collection);
copy.retainAll(expected);
assertSameElements(toString(collection), copy, expected);
}
public static String toString(Object[] collection, String separator) {
return toString(Arrays.asList(collection), separator);
}
public <T> void assertDoesntContain(Collection<? extends T> collection, T... notExpected) {
assertDoesntContain(collection, Arrays.asList(notExpected));
}
public <T> void assertDoesntContain(
Collection<? extends T> collection, Collection<T> notExpected) {
ArrayList<T> expected = new ArrayList<T>(collection);
expected.removeAll(notExpected);
assertSameElements(collection, expected);
}
public static String toString(Collection<?> collection, String separator) {
List<String> list =
ContainerUtil.map2List(
collection,
new Function<Object, String>() {
@Override
public String fun(final Object o) {
return String.valueOf(o);
}
});
Collections.sort(list);
StringBuilder builder = new StringBuilder();
boolean flag = false;
for (final String o : list) {
if (flag) {
builder.append(separator);
}
builder.append(o);
flag = true;
}
return builder.toString();
}
public static <T> void assertOrderedCollection(
Collection<? extends T> collection, Consumer<T>... checkers) {
Assert.assertNotNull(collection);
if (collection.size() != checkers.length) {
Assert.fail(toString(collection));
}
int i = 0;
for (final T actual : collection) {
try {
checkers[i].consume(actual);
} catch (AssertionFailedError e) {
System.out.println(i + ": " + actual);
throw e;
}
i++;
}
}
public static <T> void assertUnorderedCollection(T[] collection, Consumer<T>... checkers) {
assertUnorderedCollection(Arrays.asList(collection), checkers);
}
public static <T> void assertUnorderedCollection(
Collection<? extends T> collection, Consumer<T>... checkers) {
Assert.assertNotNull(collection);
if (collection.size() != checkers.length) {
Assert.fail(toString(collection));
}
Set<Consumer<T>> checkerSet = new HashSet<Consumer<T>>(Arrays.asList(checkers));
int i = 0;
Throwable lastError = null;
for (final T actual : collection) {
boolean flag = true;
for (final Consumer<T> condition : checkerSet) {
Throwable error = accepts(condition, actual);
if (error == null) {
checkerSet.remove(condition);
flag = false;
break;
} else {
lastError = error;
}
}
if (flag) {
lastError.printStackTrace();
Assert.fail("Incorrect element(" + i + "): " + actual);
}
i++;
}
}
private static <T> Throwable accepts(final Consumer<T> condition, final T actual) {
try {
condition.consume(actual);
return null;
} catch (Throwable e) {
return e;
}
}
public static <T> T assertInstanceOf(Object o, Class<T> aClass) {
Assert.assertNotNull("Expected instance of: " + aClass.getName() + " actual: " + null, o);
Assert.assertTrue(
"Expected instance of: " + aClass.getName() + " actual: " + o.getClass().getName(),
aClass.isInstance(o));
@SuppressWarnings("unchecked")
T t = (T) o;
return t;
}
public static <T> T assertOneElement(Collection<T> collection) {
Assert.assertNotNull(collection);
Assert.assertEquals(toString(collection), 1, collection.size());
return collection.iterator().next();
}
public static <T> T assertOneElement(T[] ts) {
Assert.assertNotNull(ts);
Assert.assertEquals(Arrays.asList(ts).toString(), 1, ts.length);
return ts[0];
}
public static <T> void assertOneOf(T value, T... values) {
boolean found = false;
for (T v : values) {
if (value == v || value != null && value.equals(v)) {
found = true;
}
}
Assert.assertTrue(value + " should be equal to one of " + Arrays.toString(values), found);
}
public static void printThreadDump() {
PerformanceWatcher.dumpThreadsToConsole("Thread dump:");
}
public static void assertEmpty(final Object[] array) {
assertOrderedEquals(array);
}
public static void assertNotEmpty(final Collection<?> collection) {
if (collection == null) return;
assertTrue(!collection.isEmpty());
}
public static void assertEmpty(final Collection<?> collection) {
assertEmpty(collection.toString(), collection);
}
public static void assertNullOrEmpty(final Collection<?> collection) {
if (collection == null) return;
assertEmpty(null, collection);
}
public static void assertEmpty(final String s) {
assertTrue(s, StringUtil.isEmpty(s));
}
public static <T> void assertEmpty(final String errorMsg, final Collection<T> collection) {
assertOrderedEquals(errorMsg, collection);
}
public static void assertSize(int expectedSize, final Object[] array) {
assertEquals(toString(Arrays.asList(array)), expectedSize, array.length);
}
public static void assertSize(int expectedSize, final Collection<?> c) {
assertEquals(toString(c), expectedSize, c.size());
}
protected <T extends Disposable> T disposeOnTearDown(final T disposable) {
Disposer.register(myTestRootDisposable, disposable);
return disposable;
}
public static void assertSameLines(String expected, String actual) {
String expectedText = StringUtil.convertLineSeparators(expected.trim());
String actualText = StringUtil.convertLineSeparators(actual.trim());
Assert.assertEquals(expectedText, actualText);
}
public static void assertExists(File file) {
assertTrue("File should exist " + file, file.exists());
}
public static void assertDoesntExist(File file) {
assertFalse("File should not exist " + file, file.exists());
}
protected String getTestName(boolean lowercaseFirstLetter) {
String name = getName();
return getTestName(name, lowercaseFirstLetter);
}
public static String getTestName(String name, boolean lowercaseFirstLetter) {
if (name == null) {
return "";
}
name = StringUtil.trimStart(name, "test");
if (StringUtil.isEmpty(name)) {
return "";
}
return lowercaseFirstLetter(name, lowercaseFirstLetter);
}
public static String lowercaseFirstLetter(String name, boolean lowercaseFirstLetter) {
if (lowercaseFirstLetter && !isAllUppercaseName(name)) {
name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
}
return name;
}
public static boolean isAllUppercaseName(String name) {
int uppercaseChars = 0;
for (int i = 0; i < name.length(); i++) {
if (Character.isLowerCase(name.charAt(i))) {
return false;
}
if (Character.isUpperCase(name.charAt(i))) {
uppercaseChars++;
}
}
return uppercaseChars >= 3;
}
protected String getTestDirectoryName() {
final String testName = getTestName(true);
return testName.replaceAll("_.*", "");
}
protected static void assertSameLinesWithFile(String filePath, String actualText) {
String fileText;
try {
if (OVERWRITE_TESTDATA) {
VfsTestUtil.overwriteTestData(filePath, actualText);
System.out.println("File " + filePath + " created.");
}
fileText = FileUtil.loadFile(new File(filePath), CharsetToolkit.UTF8);
} catch (FileNotFoundException e) {
VfsTestUtil.overwriteTestData(filePath, actualText);
throw new AssertionFailedError("No output text found. File " + filePath + " created.");
} catch (IOException e) {
throw new RuntimeException(e);
}
String expected = StringUtil.convertLineSeparators(fileText.trim());
String actual = StringUtil.convertLineSeparators(actualText.trim());
if (!Comparing.equal(expected, actual)) {
throw new FileComparisonFailure(null, expected, actual, filePath);
}
}
public static void clearFields(final Object test) throws IllegalAccessException {
Class aClass = test.getClass();
while (aClass != null) {
clearDeclaredFields(test, aClass);
aClass = aClass.getSuperclass();
}
}
public static void clearDeclaredFields(Object test, Class aClass) throws IllegalAccessException {
if (aClass == null) return;
for (final Field field : aClass.getDeclaredFields()) {
@NonNls final String name = field.getDeclaringClass().getName();
if (!name.startsWith("junit.framework.") && !name.startsWith("com.intellij.testFramework.")) {
final int modifiers = field.getModifiers();
if ((modifiers & Modifier.FINAL) == 0
&& (modifiers & Modifier.STATIC) == 0
&& !field.getType().isPrimitive()) {
field.setAccessible(true);
field.set(test, null);
}
}
}
}
@SuppressWarnings("deprecation")
protected static void checkSettingsEqual(
JDOMExternalizable expected, JDOMExternalizable settings, String message) throws Exception {
if (expected == null || settings == null) return;
Element oldS = new Element("temp");
expected.writeExternal(oldS);
Element newS = new Element("temp");
settings.writeExternal(newS);
String newString = JDOMUtil.writeElement(newS, "\n");
String oldString = JDOMUtil.writeElement(oldS, "\n");
Assert.assertEquals(message, oldString, newString);
}
public boolean isPerformanceTest() {
String name = getName();
return name != null && name.contains("Performance")
|| getClass().getName().contains("Performance");
}
public static void doPostponedFormatting(final Project project) {
DocumentUtil.writeInRunUndoTransparentAction(
new Runnable() {
@Override
public void run() {
PsiDocumentManager.getInstance(project).commitAllDocuments();
PostprocessReformattingAspect.getInstance(project).doPostponedFormatting();
}
});
}
protected static void checkAllTimersAreDisposed() {
try {
Class<?> aClass = Class.forName("javax.swing.TimerQueue");
Method inst = aClass.getDeclaredMethod("sharedInstance");
inst.setAccessible(true);
Object queue = inst.invoke(null);
Field field = aClass.getDeclaredField("firstTimer");
field.setAccessible(true);
Object firstTimer = field.get(queue);
if (firstTimer != null) {
try {
fail("Not disposed Timer: " + firstTimer.toString() + "; queue:" + queue);
} finally {
field.set(queue, null);
}
}
} catch (Throwable e) {
// Ignore
}
}
/**
* Checks that code block throw corresponding exception.
*
* @param exceptionCase Block annotated with some exception type
* @throws Throwable
*/
protected void assertException(final AbstractExceptionCase exceptionCase) throws Throwable {
assertException(exceptionCase, null);
}
/**
* Checks that code block throw corresponding exception with expected error msg. If expected error
* message is null it will not be checked.
*
* @param exceptionCase Block annotated with some exception type
* @param expectedErrorMsg expected error messge
* @throws Throwable
*/
protected void assertException(
final AbstractExceptionCase exceptionCase, @Nullable final String expectedErrorMsg)
throws Throwable {
assertExceptionOccurred(true, exceptionCase, expectedErrorMsg);
}
/**
* Checks that code block doesn't throw corresponding exception.
*
* @param exceptionCase Block annotated with some exception type
* @throws Throwable
*/
protected void assertNoException(final AbstractExceptionCase exceptionCase) throws Throwable {
assertExceptionOccurred(false, exceptionCase, null);
}
protected void assertNoThrowable(final Runnable closure) {
String throwableName = null;
try {
closure.run();
} catch (Throwable thr) {
throwableName = thr.getClass().getName();
}
assertNull(throwableName);
}
private static void assertExceptionOccurred(
boolean shouldOccur, AbstractExceptionCase exceptionCase, String expectedErrorMsg)
throws Throwable {
boolean wasThrown = false;
try {
exceptionCase.tryClosure();
} catch (Throwable e) {
if (shouldOccur) {
wasThrown = true;
final String errorMessage = exceptionCase.getAssertionErrorMessage();
assertEquals(errorMessage, exceptionCase.getExpectedExceptionClass(), e.getClass());
if (expectedErrorMsg != null) {
assertEquals("Compare error messages", expectedErrorMsg, e.getMessage());
}
} else if (exceptionCase.getExpectedExceptionClass().equals(e.getClass())) {
wasThrown = true;
System.out.println("");
e.printStackTrace(System.out);
fail("Exception isn't expected here. Exception message: " + e.getMessage());
} else {
throw e;
}
} finally {
if (shouldOccur && !wasThrown) {
fail(exceptionCase.getAssertionErrorMessage());
}
}
}
protected boolean annotatedWith(@NotNull Class annotationClass) {
Class<?> aClass = getClass();
String methodName = "test" + getTestName(false);
boolean methodChecked = false;
while (aClass != null && aClass != Object.class) {
if (aClass.getAnnotation(annotationClass) != null) return true;
if (!methodChecked) {
try {
Method method = aClass.getDeclaredMethod(methodName);
if (method.getAnnotation(annotationClass) != null) return true;
methodChecked = true;
} catch (NoSuchMethodException ignored) {
}
}
aClass = aClass.getSuperclass();
}
return false;
}
protected String getHomePath() {
return PathManager.getHomePath().replace(File.separatorChar, '/');
}
protected static boolean isInHeadlessEnvironment() {
return GraphicsEnvironment.isHeadless();
}
public static void refreshRecursively(@NotNull VirtualFile file) {
VfsUtilCore.visitChildrenRecursively(
file,
new VirtualFileVisitor() {
@Override
public boolean visitFile(@NotNull VirtualFile file) {
file.getChildren();
return true;
}
});
file.refresh(false, true);
}
@NotNull
public static Test filteredSuite(@RegExp String regexp, @NotNull Test test) {
final Pattern pattern = Pattern.compile(regexp);
final TestSuite testSuite = new TestSuite();
new Processor<Test>() {
@Override
public boolean process(Test test) {
if (test instanceof TestSuite) {
for (int i = 0, len = ((TestSuite) test).testCount(); i < len; i++) {
process(((TestSuite) test).testAt(i));
}
} else if (pattern.matcher(test.toString()).find()) {
testSuite.addTest(test);
}
return false;
}
}.process(test);
return testSuite;
}
}
public boolean loadSourceFile(File file) {
boolean result = false;
selectedPath = file.getParent();
BufferedReader sourceFile = null;
String directoryPath = file.getParent();
String sourceName = file.getName();
int idx = sourceName.lastIndexOf(".");
fileExt = idx == -1 ? "" : sourceName.substring(idx + 1);
baseName = idx == -1 ? sourceName.substring(0) : sourceName.substring(0, idx);
String basePath = directoryPath + File.separator + baseName;
DataOptions.directoryPath = directoryPath;
sourcePath = file.getPath();
AssemblerOptions.sourcePath = sourcePath;
AssemblerOptions.listingPath = basePath + ".lst";
AssemblerOptions.objectPath = basePath + ".cd";
String var = System.getenv("ROPE_MACROS_DIR");
if (var != null && !var.isEmpty()) {
File dir = new File(var);
if (dir.exists() && dir.isDirectory()) {
AssemblerOptions.macroPath = var;
} else {
AssemblerOptions.macroPath = directoryPath;
}
} else {
AssemblerOptions.macroPath = directoryPath;
}
DataOptions.inputPath = AssemblerOptions.objectPath;
DataOptions.outputPath = basePath + ".out";
DataOptions.readerPath = null;
DataOptions.punchPath = basePath + ".pch";
DataOptions.tape1Path = basePath + ".mt1";
DataOptions.tape2Path = basePath + ".mt2";
DataOptions.tape3Path = basePath + ".mt3";
DataOptions.tape4Path = basePath + ".mt4";
DataOptions.tape5Path = basePath + ".mt5";
DataOptions.tape6Path = basePath + ".mt6";
this.setTitle("EDIT: " + sourceName);
fileText.setText(sourcePath);
if (dialog == null) {
dialog = new AssemblerDialog(mainFrame, "Assembler options");
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension dialogSize = dialog.getSize();
dialog.setLocation(
(screenSize.width - dialogSize.width) / 2, (screenSize.height - dialogSize.height) / 2);
}
dialog.initialize();
AssemblerOptions.command = dialog.buildCommand();
sourceArea.setText(null);
try {
sourceFile = new BufferedReader(new FileReader(file));
String line;
while ((line = sourceFile.readLine()) != null) {
sourceArea.append(line + "\n");
}
sourceArea.setCaretPosition(0);
optionsButton.setEnabled(true);
assembleButton.setEnabled(true);
saveButton.setEnabled(true);
setSourceChanged(false);
undoMgr.discardAllEdits();
result = true;
} catch (IOException ex) {
ex.printStackTrace();
} finally {
try {
if (sourceFile != null) {
sourceFile.close();
}
} catch (IOException ignore) {
}
}
return result;
}
/** Return the current user desktop path. */
public static String getWindowsCurrentUserDesktopPath() {
return System.getenv("userprofile") + '/' + WINDOWS_DESKTOP;
}
public JavaGame(String[] args) {
this.args = args;
updater = new Updater(this);
highscore = new Highscore(this);
eventHandler = new EventHandler(this);
eventHandler.registerTestEvents();
setTitle("Survive-JavaGame"); // Fenstertitel setzen
setSize(1200, 900); // Fenstergröße einstellen
addWindowListener(new WindowListener());
setLocationRelativeTo(null);
try {
arg = args[0];
} catch (ArrayIndexOutOfBoundsException e) {
arg = "nothing";
}
if (arg.equals("fullscreen")) {
setUndecorated(true); // "Vollbild"
setSize(
(int) Toolkit.getDefaultToolkit().getScreenSize().getWidth() - 200,
(int) Toolkit.getDefaultToolkit().getScreenSize().getWidth());
setLocation(0, 0);
}
setVisible(true);
setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
try {
/*URI Path = URLDecoder.decode(getClass().getClassLoader().getResource("texture").toURI();//, "UTF-8"); //Pfad zu den Resourcen
File F = new File(Path);
basePath = F;
System.out.println(basePath);
*/
File File = new File((System.getenv("APPDATA")));
basePath = new File(File, "/texture");
backgroundTexture = new File(basePath, "/hintergrund.jpg");
} catch (Exception ex) {
ex.printStackTrace();
}
try {
backgroundImage = ImageIO.read(backgroundTexture);
} catch (IOException exeption) {
}
if (soundan) {
currentVolume = 80;
} // end of if
dbImage = createImage(1920, 1080);
// dbGraphics = dbImage.getGraphics();
// Texturen Liste
// Ebenen Liste
ebenen[0][0] = 91;
ebenen[0][1] = 991; // Main Ebene: Kann nicht durchschrittenwerden indem down gedrückt wird
ebenen[0][2] = 563;
ebenen[1][0] = 387; // x1
ebenen[1][1] = 524; // x2
ebenen[1][2] = 454; // y
ebenen[2][0] = 525;
ebenen[2][1] = 645;
ebenen[2][2] = 350;
ebenen[3][0] = 246;
ebenen[3][1] = 365;
ebenen[3][2] = 351;
ebenen[4][0] = 760;
ebenen[4][1] = 870;
ebenen[4][2] = 294;
ebenen[5][0] = 835;
ebenen[5][1] = 969;
ebenen[5][2] = 441;
// Spieler
// I'm in Space! SPACE!
player[1] =
new Player(
(int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
0,
false,
67,
100,
texture[0],
shottexture[0],
KeyEvent.VK_A,
KeyEvent.VK_D,
KeyEvent.VK_W,
KeyEvent.VK_S,
KeyEvent.VK_Q,
1,
35,
highscore.getName(1));
player[2] =
new Bot(
(int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
0,
false,
67,
100,
texture[1],
shottexture[1],
KeyEvent.VK_J,
KeyEvent.VK_L,
KeyEvent.VK_I,
KeyEvent.VK_K,
KeyEvent.VK_U,
2,
35,
highscore.getName(1));
player[3] =
new Bot(
(int) (Math.random() * (ebenen[0][1] - ebenen[0][0]) + ebenen[0][0]),
0,
false,
67,
100,
texture[2],
shottexture[2],
KeyEvent.VK_LEFT,
KeyEvent.VK_RIGHT,
KeyEvent.VK_UP,
KeyEvent.VK_DOWN,
KeyEvent.VK_ENTER,
3,
35,
highscore.getName(1));
player[1].laden(this);
player[2].laden(this);
player[3].laden(this);
this.addKeyListener(player[1]);
this.addKeyListener(player[2]);
this.addKeyListener(player[3]);
this.addKeyListener(this);
int result;
Object[] options = {"SinglePlayer", "MultiPlayer"};
if (arg.equals("dedicated")) {
Server server = new Server();
this.server = true;
setVisible(false);
} else {
if ((result =
JOptionPane.showOptionDialog(
null,
"Treffen Sie eine Auswahl",
"Alternativen",
JOptionPane.DEFAULT_OPTION,
JOptionPane.INFORMATION_MESSAGE,
null,
options,
options[0]))
== 1) {
client = new Client(this);
online = true;
while ((onlinename =
JOptionPane.showInputDialog(
null,
"Geben Sie Ihren Namen ein",
"Eine Eingabeaufforderung",
JOptionPane.PLAIN_MESSAGE))
.isEmpty()
&& onlinename != null) {}
Object[] optionsmp = {"Host", "Client"};
if ((result =
JOptionPane.showOptionDialog(
null,
"Treffen Sie eine Auswahl",
"Alternativen",
JOptionPane.DEFAULT_OPTION,
JOptionPane.INFORMATION_MESSAGE,
null,
optionsmp,
optionsmp[0]))
== 0) {
Server server = new Server();
this.server = true;
} else if (online) {
while ((serveradresse =
JOptionPane.showInputDialog(
null,
"Geben Sie die Serveradresse ein",
"Eine Eingabeaufforderung",
JOptionPane.PLAIN_MESSAGE))
.isEmpty()
&& serveradresse != null) {}
}
}
}
if (!arg.equals("dedicated")) {
gamerunner = new GameRunner(player, this);
DamageLogig = new damageLogig(gamerunner);
}
if (online) {
try {
client.initialise(serveradresse, 9876);
client.start();
} catch (SocketException e) {
e.printStackTrace();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
} // end of init