Testne primere sestavimo po danih navodilih. Za testne primere ustvarimo nov projekt, kateremu kot referenco pridružimo razred Letalo.
Sestavimo metodo, ki ustvari ducat objektov tipa letalo s smiselnimi vrednostmi.
Nato testni program poženemo, kjer najprej vnesemo ime datoteke, kamor bomo zapisali ducat objektov. Te nato iz datoteke preberemo in izpišemo na konzolo.
Nato testiramo delovanje spisanih metod, ki smo jih spisali po navodilih naloge.
Konkretno:
- letalom, katerih tip se začne s črko med A in M popravimo maksimalno višino za 500 metrov;
- izpišemo vsa letala, ki lahko preletijo več kot 6000 kilometrov;
- sestavimo načrt letenja za 500 potnikov za 4000 km dolg let;
- iz datoteke odstranimo vsa letala, ki imajo manj kot 150 potniških sedežev;
- letala združimo glede na tip – datoteke se nato shranijo v podmapi.
Po koncu testnih primerov še enkrat izpišemo vse objekte, ki smo jih na začetku ustvarili (shranjeni so v tabeli).
Koda testnega programa
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Letala
{
public class Letalo
{
#region privatne lastnosti
private int _doseg;
private int _maxVisina;
private int _maxHitrost;
private string _tip;
private int _stPotnikov;
#endregion
#region GET, SET
public int doseg
{
get { return this._doseg; }
set
{
if (value < 0)
throw new Exception("Vnesti je potrebno doseg večji od 0.");
else
this._doseg = value;
}
}
public int maxVisina
{
get { return this._maxVisina; }
set
{
if (value < 0)
throw new Exception("Vnesti je potrebno max višino večjo od 0.");
else
this._maxVisina = value;
}
}
public int maxHitrost
{
get { return this._maxHitrost; }
set
{
if (value < 0)
throw new Exception("Vnesti je potrebno max hitrost večjo od 0.");
else
this._maxHitrost = value;
}
}
public string tip
{
get { return this._tip; }
set { this._tip = value; }
}
public int stPotnikov
{
get { return this._stPotnikov; }
set
{
if (value < 0)
throw new Exception("Število potnikov mora biti večje ali enako 0.");
else
this._stPotnikov = value;
}
}
#endregion
#region KONSTRUKTORJI
/// <summary>
/// Minimalni konstruktor
/// </summary>
public Letalo()
{
doseg = 2000; // kilometri
maxVisina = 2000; // metri
maxHitrost = 200;
tip = "Stara šara";
stPotnikov = 5;
}
/// <summary>
/// polni konstruktor
/// </summary>
/// <param name="s">niz s podatki (doseg; maxVisina; maxHitrost; tip; stPotnikov)</param>
public Letalo(string s)
{
string[] podatki = s.Trim().Split(';');
if (podatki.Length == 5) // v vhodnem nizu moramo podatki 5 podatkov ločenih s podpičjem
{
try
{
doseg = int.Parse(podatki[0]);
maxVisina = int.Parse(podatki[1]);
maxHitrost = int.Parse(podatki[2]);
tip = podatki[3].Trim();
stPotnikov = int.Parse(podatki[4]);
}
catch (FormatException e)
{ throw new Exception("Podatki niso podani v pravem formatu" + e); }
}
else
{ throw new Exception("Premalo podatkov. Morda niste podatkov med seboj ločili s podpičjem."); }
}
#endregion
/// <summary>
/// Podatke zapiše v obliki niza, ločene s podpičjem.
/// </summary>
/// <returns></returns>
public override string ToString()
{ return doseg + "; " + maxVisina + "; " + maxHitrost + "; " + tip + "; " + stPotnikov; }
/// <summary>
/// Doda objekt this na podano tekstovno datoteko.
/// </summary>
/// <param name="imeDatoteke"></param>
public void DodajNaDatoteko(string imeDatoteke)
{
using (StreamWriter zapisi = File.AppendText(imeDatoteke))
{
zapisi.WriteLine(this.ToString());
}
}
/// <summary>
/// Vrne tabelo objektov, kjer posamezni objekt vsebuje podatke, ki so zapisani v posamezni vrstici tekstovne datoteke.
/// </summary>
/// <param name="imeDatoteke"></param>
/// <returns></returns>
public static Letalo[] PreberiZDatoteke(string imeDatoteke)
{
if (File.Exists(imeDatoteke))
{
StreamReader beri = new StreamReader(imeDatoteke);
string vsebina = beri.ReadToEnd();
beri.Close();
string[] vrstice = vsebina.Split('\n'); // vsebino datoteke razdelimo glede na skok v novo vrsto
int st=0;
for (int i = 0; i < (vrstice.Length - 1); i++)
{ // preštejemo neničelne elemente tabele
if (vrstice[i] != "")
{ st += 1; }
}
int o = 0; // ker je lahko dolžina tabele objekti manjša od dolžine taele vrstice
Letalo[] objekti = new Letalo[st]; // tabele objektov tipa Letalo
for (int j = 0; j < vrstice.Length - 1;j++ )
{
if (vrstice[j] != "")
{
objekti[o] = new Letalo(vrstice[j]);
o++;
}
}
return objekti;
}
else
{ throw new Exception("Datoteka ne obstaja!"); }
}
#region NALOGE
/// <summary>
/// Izpiše tipe vseh letal, s katerimi se lahko odpravimo na polet dane dolžine.
/// </summary>
/// <param name="seznamLetal"></param>
/// <param name="dolzina"></param>
public static void izpisiTipe(Letalo[] seznamLetal, int dolzina)
{
foreach (Letalo let in seznamLetal)
{
if (let.doseg >= dolzina)
{ Console.WriteLine(" "+let.tip+" lahko preleti "+let.doseg+" km."); }
}
}
/// <summary>
/// Popravi podatke o maksimalni višini za +500m vsem letalom v tabeli, katerih tip se začne na črke od 'A' do 'M'.
/// </summary>
/// <param name="seznamLetal"></param>
public static void popraviMaxVisino(Letalo[] seznamLetal)
{
foreach (Letalo let in seznamLetal)
{
int asciiVal = let.tip[0]; // poiščemo desetiško ascii vrednost
if (asciiVal >= 65 && asciiVal <= 77) // A ima vrednost 65, M pa 77
{ let.maxVisina += 500; }
}
}
/// <summary>
/// Izpiše načrt letenja, s katerim je možno čim hitreje prepeljati m potnikov v d kilometrov oddaljen kraj.
/// </summary>
/// <param name="leti">seznam letal</param>
/// <param name="potniki">število potnikov</param>
/// <param name="kilometri">dolžina poti</param>
/// <returns></returns>
public static void nacrtLetenja(Letalo[] leti, int potniki, int kilometri)
{
List<Letalo> newList = leti.OrderByDescending(x => x.maxHitrost).ToList(); // uredimo po hitrosti padajoč seznam
List<Letalo> ozjiIzbor= new List<Letalo>(); // pomožni seznam za letala v ožjem izboru
int stSedezev = 0; // vsota sedežev vseh letal, s katerimi bomo leteli
foreach (Letalo let in newList)
{
if (let.doseg < kilometri) // če letalo ne more preleteti dane dolžine, ga odstranimo iz urejenega seznama letal
{
newList.Remove(let);
continue;
}
if (stSedezev >= potniki)
break; // ko imamo zadosti sedežev, zanko ustavimo
stSedezev += let.stPotnikov;
ozjiIzbor.Add(let);
}
ozjiIzbor.OrderByDescending(x => x.stPotnikov);// ožji izbor letal uredimo podajoče glede na število sedežev na letalu
int naLetalu = 0; // koliko potnikov sede na letalo
foreach (Letalo l in ozjiIzbor)
{ // skupina je tako hitra, kot je hiter njen najpočasnejši član, zato pogledamo, če bi lahko vse potnike prepeljali tudi brez najhitrejših
if (l.stPotnikov < potniki) // če s tem letalom še ne prepeljemo vseh potnikov
{
naLetalu = l.stPotnikov; // letalo bo polno
potniki -= l.stPotnikov; // vrsta potnikov se zmanjša za polno letalo
Console.WriteLine("Letalo: " + l.tip + " bo peljalo " + naLetalu + " potnikov. (hitrost:"+l.maxHitrost+")");
}
else // sicer na zadnje letalo posedemo preostale potnike
{
naLetalu = potniki;
potniki = 0;
Console.WriteLine("Letalo: " + l.tip + " bo peljalo " + naLetalu + " potnikov. (hitrost:"+l.maxHitrost+")");
break; // prekinemo izvjanje zanke, saj smo vsem potnikov zagotovili sedež
}
}
}
/// <summary>
/// Iz dane datoteke s podatki o letalih odstrani vse, ki ne morejo prepeljati danega števila potnikov.
/// </summary>
/// <param name="dat">ime datoteke s podatki o letali</param>
/// <param name="stPot">število potnikov pri prevozu</param>
public static void odtraniNeustrezne(string dat, int stPot)
{
string fullPath = Path.GetFullPath(dat);
string tempPath = Path.GetTempPath();
Letalo[] letala = PreberiZDatoteke(dat);
using (StreamWriter pisi = new StreamWriter(tempPath + "\\00LetalaRez.txt"))
{
foreach (Letalo x in letala)
{
if (x.stPotnikov >= stPot)
{ pisi.WriteLine(x.ToString()); }
}
}
File.Delete(fullPath); // pobrišemo original
File.Move(tempPath + "\\00LetalaRez.txt", fullPath); // podatke z ustreznimi letali prekopiramo v datoteko z originalnim imenom
}
/// <summary>
/// Iz dane datoteke letal tvori nove datoteke letal, združene glede na tip letala. V vsaki datoteki na koncu zapiše koliko je letal v njej in koliko potnikov skupaj lahko prepeljejo.
/// </summary>
/// <param name="dat"></param>
public static void zdruziGledeNaTip(string dat)
{
Letalo[] letalaDat = PreberiZDatoteke(dat);
List<string> tipiNiz = new List<string>(); // v niz bomo shranili vse tipe, ki jih najdemo v datoteki - ločeni bodo s podpičjem
Directory.CreateDirectory("tipi");
foreach (Letalo letalo in letalaDat)
{
StreamWriter pisi;
// če že imamo datoteko s takim tipom
if (File.Exists("tipi\\" + letalo.tip + ".txt"))
{
pisi = File.AppendText("tipi\\" + letalo.tip + ".txt");
pisi.WriteLine(letalo.ToString());
}
else
{
pisi = File.AppendText("tipi\\" + letalo.tip + ".txt");
tipiNiz.Add(letalo.tip);
pisi.WriteLine(letalo.ToString());
}
pisi.Close();
}
int stLetal;
int stSedezev;
foreach (string i in tipiNiz) // za vsak tip
{
stLetal = 0;
stSedezev = 0;
Letalo[] istegaTipa = PreberiZDatoteke("tipi\\" + i + ".txt");
foreach (Letalo x in istegaTipa) // preštejemo število sedežev in letal
{
stLetal ++;
stSedezev+=x.stPotnikov;
}
using (StreamWriter zapisi = File.AppendText("tipi\\" + i + ".txt"))
{
zapisi.WriteLine("________________________________________");
zapisi.Write("število letal: " + stLetal + ", število sedežev: " + stSedezev);
}
}
Console.WriteLine("Letala so bila združena glede na tip.");
}
#endregion
}
}
