getProfilers() {
33 | return profilers;
34 | }
35 |
36 | private int getFrameId(String methodName) {
37 | if (!frameIds.containsKey(methodName)) {
38 | frames.add(methodName);
39 | frameIds.put(methodName, frames.size() - 1);
40 | }
41 |
42 | return frameIds.get(methodName);
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/infrastructure/matcher/scrimmage.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 |
3 | import util
4 | from config import *
5 |
6 | import threading, requests
7 | from apscheduler.schedulers.blocking import BlockingScheduler
8 | from queue import Queue
9 |
10 | sched = BlockingScheduler()
11 | scrim_queue = Queue()
12 |
13 | def worker():
14 | while True:
15 | scrim = scrim_queue.get()
16 | logging.info('Enqueueing scrimmage: {}'.format(scrim))
17 | result = util.enqueue({
18 | 'type': 'scrimmage',
19 | 'player1': scrim['player1'],
20 | 'player2': scrim['player2']
21 | })
22 | if result == None:
23 | scrim_queue.put(scrim)
24 |
25 | @sched.scheduled_job('cron', minute=0)
26 | def matchmake():
27 | try:
28 | logging.info('Obtaining scrimmage list')
29 | auth_token = util.get_api_auth_token()
30 | response = requests.get(url=API_SCRIM_LIST, headers={
31 | 'Authorization': 'Bearer {}'.format(auth_token)
32 | })
33 | response.raise_for_status()
34 | scrim_list = response.json()["matches"]
35 | for scrim in scrim_list:
36 | scrim_queue.put(scrim)
37 | except Exception as e:
38 | logging.critical('Could not get scrimmage list', exc_info=e)
39 |
40 | if __name__ == '__main__':
41 | threads = [threading.Thread(target=worker) for i in range(NUM_WORKER_THREADS)]
42 | for thread in threads:
43 | thread.start()
44 | sched.start()
45 |
--------------------------------------------------------------------------------
/frontend/src/components/paginationControl.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from 'react';
2 |
3 | class PaginationControl extends Component {
4 | render() {
5 | const { props } = this;
6 |
7 | if (!props.pageLimit || props.pageLimit<= 1) {
8 | return null;
9 | };
10 |
11 | const items = [];
12 | const isFirst = props.page === 1;
13 | const isLast = props.page === props.pageLimit;
14 |
15 | items.push(
16 |
17 | props.onPageClick(props.page - 1)}>Previous
18 |
19 | );
20 |
21 |
22 | for (let i = 1; i <= props.pageLimit; i++) {
23 | items.push(
24 |
25 | props.onPageClick(i)}>{i}
26 |
27 | )
28 | }
29 |
30 | items.push(
31 |
32 | props.onPageClick(props.page + 1)}>Next
33 |
34 | );
35 |
36 | return (
37 |
40 | )
41 | }
42 | }
43 |
44 | export default PaginationControl;
--------------------------------------------------------------------------------
/engine/src/main/battlecode/common/Team.java:
--------------------------------------------------------------------------------
1 | package battlecode.common;
2 |
3 | /**
4 | * This enum represents the team of a robot. A robot is on exactly one team.
5 | * Player robots are on either team A or team B.
6 | *
7 | * Since Team is a Java 1.5 enum, you can use it in switch
8 | * statements, it has all the standard enum methods (valueOf,
9 | * values, etc.), and you can safely use == for
10 | * equality tests.
11 | */
12 | public enum Team {
13 | /**
14 | * Team A.
15 | */
16 | A,
17 | /**
18 | * Team B.
19 | */
20 | B,
21 | /**
22 | * Neutral robots.
23 | */
24 | NEUTRAL;
25 |
26 | /**
27 | * Determines the team that is the opponent of this team.
28 | *
29 | * @return the opponent of this team.
30 | *
31 | * @battlecode.doc.costlymethod
32 | */
33 | public Team opponent() {
34 | switch (this) {
35 | case A:
36 | return B;
37 | case B:
38 | return A;
39 | default:
40 | return NEUTRAL;
41 | }
42 | }
43 |
44 | /**
45 | * Returns whether a robot of this team is a player-controlled entity
46 | * (team A or team B).
47 | *
48 | * @return true a robot of this team is player-controlled; false otherwise.
49 | *
50 | * @battlecode.doc.costlymethod
51 | */
52 | public boolean isPlayer() {
53 | return this == A || this == B;
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/example-bots/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'java'
2 | apply plugin: 'scala'
3 |
4 | // You can specify players to release here, or on the command line,
5 | // with the setting here taking priority. Note that leaving this
6 | // blank (i.e., an empty string) results in the release of all players.
7 | // To release no players, set this to 'NONE'.
8 | // WE DONT SUPPORT THIS ANYMORE
9 | project.ext.release_players='NONE'
10 |
11 | repositories {
12 | mavenCentral()
13 | maven {url "https://oss.sonatype.org/content/repositories/snapshots/"}
14 | jcenter()
15 | }
16 |
17 | sourceSets {
18 | main {
19 | scala.srcDirs = ["src/main"]
20 |
21 | // output.classesDir = "$buildDir/classes"
22 | java.outputDir = file("$buildDir/classes")
23 | scala.outputDir = file("$buildDir/classes")
24 | }
25 | test {
26 | scala.srcDirs = ["src/test"]
27 |
28 | // output.classesDir = "$buildDir/tests"
29 | java.outputDir = file("$buildDir/tests")
30 | scala.outputDir = file("$buildDir/tests")
31 | }
32 | // main.java.srcDirs += 'src/main/kotlin'
33 | }
34 |
35 | dependencies {
36 | compile project(':engine')
37 |
38 | // scala
39 | compile group: 'org.scala-lang', name: 'scala-library', version: '2.12.1'
40 |
41 |
42 |
43 | // Testing dependencies
44 | testCompile 'junit:junit:4.12'
45 | }
46 |
47 | jar {
48 | if (project.hasProperty('release_players'))
49 | for (String player : project.property('release_players').split(','))
50 | include "**/" + player + "/*.class"
51 |
52 | includeEmptyDirs = false
53 | }
54 |
--------------------------------------------------------------------------------
/infrastructure/tournament-util/finals_seeds.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # Usage: finals_seeds.py CSV_FILE
3 |
4 | import sys, os, requests
5 |
6 | KEY = os.getenv('BC20_CHALLONGE_KEY')
7 |
8 | response = requests.get(url='https://api.challonge.com/v1/tournaments/bc20_seeding/participants.json?api_key={}'.format(KEY))
9 | response.raise_for_status()
10 |
11 | seeded = {}
12 | for team in response.json():
13 | seeded[team['participant']['name']] = team['participant']['final_rank']
14 |
15 | def calculate_value(seed, score, winner_bracket):
16 | return score + 500 * winner_bracket - 10 * seed
17 |
18 | teams = []
19 | with open(sys.argv[1], 'r') as f:
20 | f.readline() # Skip the title row
21 | for line in f.readlines():
22 | team_id, team_name, team_score, team_winner_bracket = line.split(',')
23 | team_score, team_winner_bracket = float(team_score), int(team_winner_bracket)
24 | team_name = team_name[1:-1] # Remove quotation marks
25 | team_seed = seeded[team_name]
26 | team_value = calculate_value(team_seed, team_score, team_winner_bracket)
27 | teams.append((team_value, team_id, team_name, team_seed, team_score, team_winner_bracket))
28 | teams.sort(key=lambda x: -x[0])
29 |
30 | with open('team_pk', 'w') as g:
31 | with open('team_names', 'w') as h:
32 | for team in teams:
33 | team_value, team_id, team_name, team_seed, team_score, team_winner_bracket = team
34 | print (team)
35 | g.write(team_id+'\n')
36 | h.write(team_name+'\n')
37 |
--------------------------------------------------------------------------------
/client/visualizer/src/game/nextstep.ts:
--------------------------------------------------------------------------------
1 | import {StructOfArrays, Metadata, GameWorld, schema} from 'battlecode-playback';
2 |
3 | export type NextStepSchema = {
4 | id: Int32Array,
5 | x: Int32Array,
6 | y: Int32Array
7 | }
8 |
9 | /**
10 | * For interpolated rendering.
11 | */
12 | export default class NextStep {
13 | /**
14 | * {
15 | * id: Int32Array,
16 | * x: Int32Array,
17 | * y: Int32Array
18 | * }
19 | */
20 | bodies: StructOfArrays;
21 |
22 | // Cache fields
23 | private _vecTableSlot: schema.VecTable;
24 |
25 | constructor() {
26 | this.bodies = new StructOfArrays({
27 | id: new Int32Array(0),
28 | x: new Int32Array(0),
29 | y: new Int32Array(0)
30 | }, 'id');
31 | this._vecTableSlot = new schema.VecTable();
32 | }
33 |
34 | /**
35 | * Load where robots will be in the next time step,
36 | * so that we can smoothly transition between steps.
37 | */
38 | loadNextStep(world: GameWorld, delta: schema.Round) {
39 | this.bodies.copyFrom(world.bodies);
40 | if (delta.roundID() != world.turn + 1) {
41 | throw new Error(`Bad Round [lerp]: world.turn = ${world.turn}, round.roundID() = ${delta.roundID()}`);
42 | }
43 |
44 | const movedLocs = delta.movedLocs(this._vecTableSlot);
45 | if(delta!==null && movedLocs!==null){
46 | this.bodies.alterBulk({
47 | id: delta.movedIDsArray(),
48 | x: movedLocs.xsArray(),
49 | y: movedLocs.ysArray()
50 | });
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/schema/java/battlecode/schema/GameFooter.java:
--------------------------------------------------------------------------------
1 | // automatically generated by the FlatBuffers compiler, do not modify
2 |
3 | package battlecode.schema;
4 |
5 | import java.nio.*;
6 | import java.lang.*;
7 | import java.util.*;
8 | import com.google.flatbuffers.*;
9 |
10 | @SuppressWarnings("unused")
11 | /**
12 | * The final event sent in the game.
13 | */
14 | public final class GameFooter extends Table {
15 | public static GameFooter getRootAsGameFooter(ByteBuffer _bb) { return getRootAsGameFooter(_bb, new GameFooter()); }
16 | public static GameFooter getRootAsGameFooter(ByteBuffer _bb, GameFooter obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
17 | public GameFooter __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
18 |
19 | /**
20 | * The ID of the winning team of the game.
21 | */
22 | public byte winner() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; }
23 |
24 | public static int createGameFooter(FlatBufferBuilder builder,
25 | byte winner) {
26 | builder.startObject(1);
27 | GameFooter.addWinner(builder, winner);
28 | return GameFooter.endGameFooter(builder);
29 | }
30 |
31 | public static void startGameFooter(FlatBufferBuilder builder) { builder.startObject(1); }
32 | public static void addWinner(FlatBufferBuilder builder, byte winner) { builder.addByte(0, winner, 0); }
33 | public static int endGameFooter(FlatBufferBuilder builder) {
34 | int o = builder.endObject();
35 | return o;
36 | }
37 | }
38 |
39 |
--------------------------------------------------------------------------------
/engine/src/main/battlecode/schema/GameFooter.java:
--------------------------------------------------------------------------------
1 | // automatically generated by the FlatBuffers compiler, do not modify
2 |
3 | package battlecode.schema;
4 |
5 | import java.nio.*;
6 | import java.lang.*;
7 | import java.util.*;
8 | import com.google.flatbuffers.*;
9 |
10 | @SuppressWarnings("unused")
11 | /**
12 | * The final event sent in the game.
13 | */
14 | public final class GameFooter extends Table {
15 | public static GameFooter getRootAsGameFooter(ByteBuffer _bb) { return getRootAsGameFooter(_bb, new GameFooter()); }
16 | public static GameFooter getRootAsGameFooter(ByteBuffer _bb, GameFooter obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
17 | public GameFooter __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
18 |
19 | /**
20 | * The ID of the winning team of the game.
21 | */
22 | public byte winner() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; }
23 |
24 | public static int createGameFooter(FlatBufferBuilder builder,
25 | byte winner) {
26 | builder.startObject(1);
27 | GameFooter.addWinner(builder, winner);
28 | return GameFooter.endGameFooter(builder);
29 | }
30 |
31 | public static void startGameFooter(FlatBufferBuilder builder) { builder.startObject(1); }
32 | public static void addWinner(FlatBufferBuilder builder, byte winner) { builder.addByte(0, winner, 0); }
33 | public static int endGameFooter(FlatBufferBuilder builder) {
34 | int o = builder.endObject();
35 | return o;
36 | }
37 | }
38 |
39 |
--------------------------------------------------------------------------------
/engine/src/test/battlecode/instrumenter/sample/instrumentertest/CallsIllegalMethods.java:
--------------------------------------------------------------------------------
1 | package instrumentertest;
2 |
3 | import java.io.PrintStream;
4 |
5 | @SuppressWarnings("unused")
6 | public class CallsIllegalMethods {
7 | public static class CallsWait {
8 | static {
9 | try {
10 | new Object().wait();
11 | } catch (Exception e) {
12 | throw new RuntimeException(e);
13 | }
14 | }
15 | }
16 |
17 | public static class CallsClassForName {
18 | static {
19 | try {
20 | Class.forName("???");
21 | } catch (Exception e) {
22 | throw new RuntimeException(e);
23 | }
24 | }
25 | }
26 |
27 | public static class CallsStringIntern {
28 | static {
29 | try {
30 | "???".intern();
31 | } catch (Exception e) {
32 | throw new RuntimeException(e);
33 | }
34 | }
35 | }
36 |
37 | public static class CallsSystemNanoTime {
38 | static {
39 | try {
40 | System.nanoTime();
41 | } catch (Exception e) {
42 | throw new RuntimeException(e);
43 | }
44 | }
45 | }
46 |
47 | public static class CreatesFilePrintStream {
48 | static {
49 | try {
50 | new PrintStream("???");
51 | } catch (Exception e) {
52 | throw new RuntimeException(e);
53 | }
54 | }
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/client/visualizer/src/electron-modules.ts:
--------------------------------------------------------------------------------
1 | // This file is a dirty hack that is necessary because nobody expected anyone
2 | // to make an app that runs both in the browser and electron.
3 |
4 | // To add another electron-exclusive module, add it to this file,
5 | // and add it to 'externals' for non-webpack in webpack.config.js
6 |
7 | // if we're on the web, we define these objects to be null
8 | // they will ERROR AT RUNTIME if used
9 | // only use them if you've made sure that process.env.ELECTRON === true
10 |
11 | // ambient webpack function: creates modules
12 | declare function define(...args: any[]);
13 |
14 | // only define if non-browser
15 | if (!process.env.ELECTRON) {
16 | define('electron', [], () => null);
17 | define('os', [], () => null);
18 | define('fs', [], () => null);
19 | define('path', [], () => null);
20 | define('child_process', [], () => null);
21 | define('http', [], () => null);
22 | }
23 |
24 | // in electron, actually imports
25 | // in browser, imports null
26 | import * as _electron from 'electron';
27 | import * as _os from 'os';
28 | import * as _fs from 'fs';
29 | import * as _path from 'path';
30 | import * as _child_process from 'child_process';
31 | import * as _http from 'http';
32 |
33 | export var electron = _electron;
34 | export var os = _os;
35 | export var fs = _fs;
36 | export var path = _path;
37 | export var child_process = _child_process;
38 | export var http = _http;
39 |
40 | export default {
41 | electron: _electron,
42 | os: _os,
43 | fs: _fs,
44 | path: _path,
45 | child_process: _child_process,
46 | http: _http
47 | }
48 |
--------------------------------------------------------------------------------
/infrastructure/Makefile:
--------------------------------------------------------------------------------
1 | .PHONY: env worker compile game scrimmage tournament images push clean
2 |
3 | # Basic environment variables for docker images
4 | env:
5 | docker build - < env.Dockerfile -t bc20-env
6 |
7 | # Worker servers: compilation server and game runner server
8 | worker: env
9 | docker build -f worker.Dockerfile -t bc20-worker worker
10 | compile: worker
11 | docker build -f compile.Dockerfile -t bc20-compile worker
12 | game: worker
13 | docker build -f game.Dockerfile -t bc20-game worker
14 |
15 | # Matchmaking servers: scrimmage matchmaking and tournament running
16 | scrimmage: env
17 | docker build -f scrimmage.Dockerfile -t bc20-scrimmage matcher
18 | tournament: env
19 | docker build -f tournament.Dockerfile -t bc20-tournament matcher
20 |
21 | images: compile game scrimmage tournament
22 |
23 | # Push to google container registry
24 | push: images
25 | docker tag bc20-compile gcr.io/battlecode18/bc20-compile
26 | docker tag bc20-game gcr.io/battlecode18/bc20-game
27 | docker tag bc20-scrimmage gcr.io/battlecode18/bc20-scrimmage
28 | docker tag bc20-tournament gcr.io/battlecode18/bc20-tournament
29 | docker push gcr.io/battlecode18/bc20-compile
30 | docker push gcr.io/battlecode18/bc20-game
31 | docker push gcr.io/battlecode18/bc20-scrimmage
32 | docker push gcr.io/battlecode18/bc20-tournament
33 |
34 | clean:
35 | docker rmi -f bc20-env bc20-worker bc20-compile bc20-game bc20-scrimmage bc20-tournament
36 | docker rmi -f gcr.io/battlecode18/bc20-compile gcr.io/battlecode18/bc20-game gcr.io/battlecode18/bc20-scrimmage gcr.io/battlecode18/bc20-tournament
37 |
--------------------------------------------------------------------------------
/schema/java/battlecode/schema/Event.java:
--------------------------------------------------------------------------------
1 | // automatically generated by the FlatBuffers compiler, do not modify
2 |
3 | package battlecode.schema;
4 |
5 | /**
6 | * An Event is a single step that needs to be processed.
7 | * A saved game simply consists of a long list of Events.
8 | * Events can be divided by either being sent separately (e.g. as separate
9 | * websocket messages), or by being wrapped with a GameWrapper.
10 | * A game consists of a series of matches; a match consists of a series of
11 | * rounds, and is played on a single map. Each round is a single simulation
12 | * step.
13 | */
14 | public final class Event {
15 | private Event() { }
16 | public static final byte NONE = 0;
17 | /**
18 | * There should only be one GameHeader, at the start of the stream.
19 | */
20 | public static final byte GameHeader = 1;
21 | /**
22 | * There should be one MatchHeader at the start of each match.
23 | */
24 | public static final byte MatchHeader = 2;
25 | /**
26 | * A single simulation step. A round may be skipped if
27 | * nothing happens during its time.
28 | */
29 | public static final byte Round = 3;
30 | /**
31 | * There should be one MatchFooter at the end of each simulation step.
32 | */
33 | public static final byte MatchFooter = 4;
34 | /**
35 | * There should only be one GameFooter, at the end of the stream.
36 | */
37 | public static final byte GameFooter = 5;
38 |
39 | public static final String[] names = { "NONE", "GameHeader", "MatchHeader", "Round", "MatchFooter", "GameFooter", };
40 |
41 | public static String name(int e) { return names[e]; }
42 | }
43 |
44 |
--------------------------------------------------------------------------------
/engine/src/main/battlecode/schema/Event.java:
--------------------------------------------------------------------------------
1 | // automatically generated by the FlatBuffers compiler, do not modify
2 |
3 | package battlecode.schema;
4 |
5 | /**
6 | * An Event is a single step that needs to be processed.
7 | * A saved game simply consists of a long list of Events.
8 | * Events can be divided by either being sent separately (e.g. as separate
9 | * websocket messages), or by being wrapped with a GameWrapper.
10 | * A game consists of a series of matches; a match consists of a series of
11 | * rounds, and is played on a single map. Each round is a single simulation
12 | * step.
13 | */
14 | public final class Event {
15 | private Event() { }
16 | public static final byte NONE = 0;
17 | /**
18 | * There should only be one GameHeader, at the start of the stream.
19 | */
20 | public static final byte GameHeader = 1;
21 | /**
22 | * There should be one MatchHeader at the start of each match.
23 | */
24 | public static final byte MatchHeader = 2;
25 | /**
26 | * A single simulation step. A round may be skipped if
27 | * nothing happens during its time.
28 | */
29 | public static final byte Round = 3;
30 | /**
31 | * There should be one MatchFooter at the end of each simulation step.
32 | */
33 | public static final byte MatchFooter = 4;
34 | /**
35 | * There should only be one GameFooter, at the end of the stream.
36 | */
37 | public static final byte GameFooter = 5;
38 |
39 | public static final String[] names = { "NONE", "GameHeader", "MatchHeader", "Round", "MatchFooter", "GameFooter", };
40 |
41 | public static String name(int e) { return names[e]; }
42 | }
43 |
44 |
--------------------------------------------------------------------------------
/engine/src/main/battlecode/common/Clock.java:
--------------------------------------------------------------------------------
1 | package battlecode.common;
2 |
3 | import battlecode.instrumenter.inject.RobotMonitor;
4 |
5 | /**
6 | * Clock is a singleton that allows contestants to introspect the state of their running
7 | * code.
8 | *
9 | * @author james
10 | */
11 | @SuppressWarnings("unused")
12 | public final class Clock {
13 |
14 | /**
15 | * IMPORTANT NOTE!
16 | * This class is reloaded for every individual robot.
17 | * See Loader for more information.
18 | */
19 |
20 | /**
21 | * Ends the processing of this robot during the current round. Never fails.
22 | *
23 | * @battlecode.doc.costlymethod
24 | */
25 | public static void yield() {
26 | RobotMonitor.pause();
27 | }
28 |
29 | /**
30 | * Returns the number of bytecodes this robot has left in this round.
31 | * @return the number of bytecodes this robot has left in this round.
32 | *
33 | * @battlecode.doc.costlymethod
34 | */
35 | public static int getBytecodesLeft() {
36 | return RobotMonitor.getBytecodesLeft();
37 | }
38 |
39 | /**
40 | * Returns the number of bytecodes the current robot has executed since the beginning
41 | * of the current round.
42 | * @return the number of bytecodes the current robot has executed since the beginning
43 | * of the current round.
44 | *
45 | * @battlecode.doc.costlymethod
46 | */
47 | public static int getBytecodeNum() {
48 | return RobotMonitor.getBytecodeNum();
49 | }
50 |
51 | /**
52 | * Prevent construction.
53 | */
54 | private Clock() {}
55 | }
56 |
--------------------------------------------------------------------------------
/engine/src/test/battlecode/util/SquareArrayTest.java:
--------------------------------------------------------------------------------
1 | package battlecode.util;
2 |
3 | import org.junit.Test;
4 |
5 | import static org.junit.Assert.assertEquals;
6 |
7 | /**
8 | * @author james
9 | */
10 | public class SquareArrayTest {
11 | @Test
12 | public void testDouble() {
13 | SquareArray.Double arr = new SquareArray.Double(10, 7);
14 | assertEquals(10, arr.width);
15 | assertEquals(7, arr.height);
16 | for (int x = 0; x < arr.width; x++) {
17 | for (int y = 0; y < arr.height; y++) {
18 | arr.set(x, y, x * 1000 + y);
19 | assertEquals(x * 1000 + y, arr.get(x, y), 1e-9);
20 | }
21 | }
22 | }
23 |
24 | @Test
25 | public void testBoolean() {
26 | SquareArray.Boolean arr = new SquareArray.Boolean(10, 7);
27 | assertEquals(10, arr.width);
28 | assertEquals(7, arr.height);
29 | for (int x = 0; x < arr.width; x++) {
30 | for (int y = 0; y < arr.height; y++) {
31 | arr.set(x, y, (x+y) % 2 == 5);
32 | assertEquals((x+y) % 2 == 5, arr.get(x, y));
33 | }
34 | }
35 | }
36 |
37 | @Test
38 | public void testObject() {
39 | SquareArray.Of