public void one_cube_is_contained_within_the_other()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(1).Build();
Assert.AreEqual(1, cubeA.IntersectionVolumeWith(cubeB));
}
public void cubes_that_do_not_touch()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(10, 10, 10).WithEdgeLength(2).Build();
Assert.IsFalse(cubeA.CollidesWith(cubeB));
}
public void cubes_with_same_width_and_height()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(2, 2, 3).WithEdgeLength(2).Build();
Assert.AreEqual(4, cubeA.IntersectionVolumeWith(cubeB));
}
public void cubes_that_do_not_intersect()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(10, 10, 10).WithEdgeLength(2).Build();
Assert.AreEqual(0, cubeA.IntersectionVolumeWith(cubeB));
}
static void Main(string[] args)
{
int x, y, z;
System.Console.WriteLine(" *** Cube 1 *** ");
System.Console.WriteLine("X:");
_ = int.TryParse(System.Console.ReadLine(), out x);
System.Console.WriteLine("Y:");
_ = int.TryParse(System.Console.ReadLine(), out y);
System.Console.WriteLine("Z:");
_ = int.TryParse(System.Console.ReadLine(), out z);
CubeService service = new CubeService();
var cube1 = service.Create(new ThreeAxesOriginCoordinates {
X = x, Y = y, Z = z
});
System.Console.WriteLine(" *** Cube 1 *** ");
System.Console.WriteLine("X:");
_ = int.TryParse(System.Console.ReadLine(), out x);
System.Console.WriteLine("Y:");
_ = int.TryParse(System.Console.ReadLine(), out y);
System.Console.WriteLine("Z:");
_ = int.TryParse(System.Console.ReadLine(), out z);
var cube2 = service.Create(new ThreeAxesOriginCoordinates {
X = x, Y = y, Z = z
});
System.Console.WriteLine($"Area Cube 1: {cube1.CalculateArea().ToString()}");
System.Console.WriteLine($"Volume Cube 2: {cube2.CalculateVolume().ToString()}");
System.Console.ReadKey();
}
public void cubes_are_touching_but_not_intersecting()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(4, 2, 2).WithEdgeLength(2).Build();
Assert.AreEqual(0, cubeA.IntersectionVolumeWith(cubeB));
}
public void cubes_that_overlap()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(3, 2, 2).WithEdgeLength(2).Build();
Assert.IsTrue(cubeA.CollidesWith(cubeB));
}
public void cubes_are_completely_overlapped()
{
var cubeA = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
var cubeB = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
Assert.AreEqual(8, cubeA.IntersectionVolumeWith(cubeB));
}
public void is_commutative()
{
var cubeA = new CubeService().CenteredAt(0, 0, 0).WithEdgeLength(3).Build();
var cubeB = new CubeService().CenteredAt(2, 2, 2).WithEdgeLength(2).Build();
Assert.AreEqual(cubeA.IntersectionVolumeWith(cubeB),
cubeB.IntersectionVolumeWith(cubeA));
}
public void Initialize()
{
LocationService = new LocationService(LocationsInfo);
ExperienceManager = new ExperienceManager(this);
InventoryService = new InventoryService(Inventory);
CubeService = new CubeService(this);
SkillService = new SkillService(this, Skills);
EffectService = new EffectService(this, Effects);
}
// Use this for initialization
void Start()
{
var player = FindObjectOfType <GameState>().Player;
InventoryService = player.InventoryService;
Inventory.InventoryService = InventoryService;
CubeService = new CubeService(player);
_resourceManager = FindObjectOfType <ResourceManager>();
_cubeItemSlots = ItemSlots.Select(s => s.GetComponent <InventorySlot>()).ToList();
EventsSubscribe();
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
CubeService wservice = new CubeService();
Position wpositionCubeA = wservice.setCubePosition(Double.Parse(txtCoordXCubeA.Text), Double.Parse(txtCoordYCubeA.Text), Double.Parse(txtCoordZCubeA.Text));
CubeDimensions wdimensionCubeA = wservice.setCubeDimensions(Double.Parse(txtHeightCubeA.Text), Double.Parse(txtLengthCubeA.Text), Double.Parse(txtWidthCubeA.Text));
Cube wcubeA = new Cube(wpositionCubeA, wdimensionCubeA);
Position wpositionCubeB = wservice.setCubePosition(Double.Parse(txtCoordXCubeB.Text), Double.Parse(txtCoordYCubeB.Text), Double.Parse(txtCoordZCubeB.Text));
CubeDimensions wdimensionCubeB = wservice.setCubeDimensions(Double.Parse(txtHeightCubeB.Text), Double.Parse(txtLengthCubeB.Text), Double.Parse(txtWidthCubeB.Text));
Cube wcubeB = new Cube(wpositionCubeB, wdimensionCubeB);
}
public void CubeService_OneCubeIsContainedWithinTheOther()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(2, 2, 2), 1);
// Act
var result = cubeService.IntersectionVolumeWith(cubeA, cubeB);
// Assert
Assert.Equal(1, result);
}
public void CubeService_AreCompletelyOverlapped()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(2, 2, 2), 2);
// Act
var result = cubeService.IntersectionVolumeWith(cubeA, cubeB);
// Assert
Assert.Equal(8, result);
}
public void CubeService_WithSameWithAndDepth()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(2, 3, 2), 2);
// Act
var result = cubeService.IntersectionVolumeWith(cubeA, cubeB);
// Assert
Assert.Equal(4, result);
}
public void CubeService_ThatDoNotIntersect()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(10, 10, 10), 2);
// Act
var result = cubeService.IntersectionVolumeWith(cubeA, cubeB);
// Assert
Assert.Equal(0, result);
}
public void CubeService_ThatOverlap_ShouldReturnTrue()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(3, 2, 2), 2);
// Act
var result = cubeService.CollidesWith(cubeA, cubeB);
// Assert
Assert.True(result);
}
public void CubeService_AreTouchingButNotIntersecting()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(4, 2, 2), 2);
// Act
var result = cubeService.IntersectionVolumeWith(cubeA, cubeB);
// Assert
Assert.Equal(0, result);
}
public void CubeService_ThatDoNotCollides_ShouldReturnFalse()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(2, 2, 2), 2);
var cubeB = new Cube(new Position(10, 10, 10), 2);
// Act
var result = cubeService.CollidesWith(cubeA, cubeB);
// Assert
Assert.False(result);
}
private void calculateCubeVolume()
{
if (cubeVolumeCheckBox.Checked)
{
if (int.TryParse(cubeSideTextBox.Text.Trim(), out side))
{
Figure3DService <Cube> cubeService = new CubeService();
double cubeVolume = cubeService.calculateVolume(side);
String volumeResult = String.Format("Cube volume is: {0} for side: {1}", counter++, cubeVolume, side);
Console.WriteLine(volumeResult);
result.Add(volumeResult);
}
}
}
public void CubeService_IsCommutative()
{
// Arrange
var cubeService = new CubeService(new BorderService());
var cubeA = new Cube(new Position(0, 0, 0), 3);
var cubeB = new Cube(new Position(2, 2, 2), 2);
// Act
var resultA = cubeService.IntersectionVolumeWith(cubeA, cubeB);
var resultB = cubeService.IntersectionVolumeWith(cubeB, cubeA);
// Assert
Assert.Equal(resultA, resultB);
}
private void calculateCubeArea()
{
if (cubeAreaCheckBox.Checked)
{
if (int.TryParse(cubeSideTextBox.Text.Trim(), out side))
{
Figure3DService <Cube> cubeService = new CubeService();
double cubeArea = cubeService.calculateArea(side);
String areaResult = String.Format("{0}. Cube area is: {1} for side: {2}", counter++, cubeArea, side);
Console.WriteLine(result);
result.Add(areaResult);
}
}
}
public void TestMethod1()
{
double HeightCubeA = 10.5;
double LengthCubeA = 4.2;
double WidthCubeA = 22.7;
double CoordXCubeA = 2;
double CoordYCubeA = 2;
double CoordZCubeA = 2;
double HeightCubeB = 10.5;
double LengthCubeB = 4.2;
double WidthCubeB = 22.7;
double CoordXCubeB = 10;
double CoordYCubeB = 10;
double CoordZCubeB = 10;
CubeService wservice = new CubeService();
Position wpositionCubeA = wservice.setCubePosition(CoordXCubeA, CoordYCubeA, CoordZCubeA);
CubeDimensions wdimensionCubeA = wservice.setCubeDimensions(HeightCubeA, LengthCubeA, WidthCubeA);
Cube wcubeA = new Cube(wpositionCubeA, wdimensionCubeA);
Console.WriteLine("Cube A");
Console.WriteLine("Position(X: " + wcubeA.Position.CoordinateX.ToString() + ";Y: " + wcubeA.Position.CoordinateY.ToString() + ";Z: " + wcubeA.Position.CoordinateZ.ToString() + ")");
Console.WriteLine("Dimensions(H: " + wcubeA.Dimensions.Height.ToString() + ";L: " + wcubeA.Dimensions.Length.ToString() + ";W: " + wcubeA.Dimensions.Width.ToString() + ")");
Console.WriteLine("");
Position wpositionCubeB = wservice.setCubePosition(CoordXCubeB, CoordYCubeB, CoordZCubeB);
CubeDimensions wdimensionCubeB = wservice.setCubeDimensions(HeightCubeB, LengthCubeB, WidthCubeB);
Cube wcubeB = new Cube(wpositionCubeB, wdimensionCubeB);
Console.WriteLine("Cube B");
Console.WriteLine("Position(X: " + wcubeB.Position.CoordinateX.ToString() + ";Y: " + wcubeB.Position.CoordinateY.ToString() + ";Z: " + wcubeB.Position.CoordinateZ.ToString() + ")");
Console.WriteLine("Dimensions(H: " + wcubeB.Dimensions.Height.ToString() + ";L: " + wcubeB.Dimensions.Length.ToString() + ";W: " + wcubeB.Dimensions.Width.ToString() + ")");
Console.WriteLine("");
if (wservice.cubesCollide(wcubeA, wcubeB))
{
Console.WriteLine("The cubes Collide!");
}
else
{
Console.WriteLine("The cubes does not Collide!");
}
}
public JsonResult ProcesarOperaciones(string value)
{
try
{
if (string.IsNullOrEmpty(value))
{
return(Json(new RespuestaGeneral {
EstadoOperacion = false, Mensaje = "Los datos estan vacios"
}));
}
var operacion = new CubeService();
var respuesta = operacion.Ejecutar(value);
return(Json(respuesta));
}
catch (Exception ex)
{
// Al ser u excepción del sistema debe grabara el error en algun log o visor de eventos de windows.
// El usuario nunca debe recibir errores del sistema.
return(Json(new RespuestaGeneral {
EstadoOperacion = false, Mensaje = "Se ha presentado un error"
}));
}
}
public ActionResult <int> Get(int value)
{
return(CubeService.Cube(value));
}
public void TestCube()
{
Assert.Equal(8, CubeService.Cube(2));
}
public void Setup()
{
var geometryClient = new GeometryClient();
_cubeService = new CubeService(geometryClient);
}
public UnitTest1(CubeService cubeService)
{
_cubeService = cubeService;
}
