diff --git a/ovinger/oppgavetekster/README.md b/ovinger/oppgavetekster/README.md
index 1eb61d9eb05fcbb782f6e19733d52334e59cf792..7dfacc323d7f831f9e8b5db190e8e5a7c457b637 100644
--- a/ovinger/oppgavetekster/README.md
+++ b/ovinger/oppgavetekster/README.md
@@ -7,7 +7,7 @@ Denne mappen inneholder øvingstekster for TDT4100 - Objektorientert programmeri
| [Øving 1](oving1/README.md) | Tilstand og oppførsel |
| [Øving 2](oving2/README.md) | Innkapsling og validering |
| [Øving 3](oving3/README.md) | Klasser og testing |
-| Øving 4 | Objektstrukturer |
+| [Øving 4](oving4/README.md) | Objektstrukturer |
| Øving 5 | Grensesnitt |
| Øving 6 | Observatør-observert og delegering |
| Øving 7 | Arv og abstrakte klasser |
diff --git a/ovinger/oppgavetekster/oving4/Card.md b/ovinger/oppgavetekster/oving4/Card.md
new file mode 100644
index 0000000000000000000000000000000000000000..9f9dc794b7a7b1646bac4dfca7de73deee245229
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/Card.md
@@ -0,0 +1,24 @@
+# Objektstrukturer - Card-oppgave del 2
+
+Denne oppgaven handler om klasser for kortspill: `Card` (kort), `CardDeck` (kortstokk) og `CardHand` (korthånd), hvorav de to siste inneholder én eller flere `Card`-objekter. Oppgaven bygger på `Card` og `CardDeck` i [Innkapsling - Card-oppgave](../oving3/Card.md).
+
+**Merk**: Om du ikke har gjort `Card`-oppgaven allerede, kan du bruke løsningsforslaget som er lagt ut under `lf/src/main/java/encapsulation`.
+
+I mange sammenhenger vil objekter av en klasse inneholde eller "eie" objekter av andre klasser, og de underordnede objektene vil kunne flyttes/overføres mellom de overordnede. Når en klasse er assosiert med én instans av en (annen) klasse er dette en [1-1-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-1-assosiasjoner) og når en klasse er assosiert med flere instanser av en annen klasse er dette en [1-n-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-n-assosiasjoner). Et eksempel er kortspill, hvor kortene starter i kortstokken, fordeles på korthender og til slutt ender i en kortbunke. Et kort kan bare være ett sted om gangen, og må overføres fra ett sted til et annet, f.eks. fra kortstokk til korthender i utdelingsfasen. I [Innkapsling - Card-oppgave](../oving3/Card.md) ble det lagd logikk for kortstokk og enkeltkort. I denne oppgaven skal du implementere logikk for korthender, og utvide kortstokkens logikk litt.
+
+`Card`-klassen har du allerede implementert, men du må sannsynligvis kopiere koden over fra `encapsulation` til `objectstructures`. Her er det enklest å lage en ny `Card`-klasse i `objectstructures` og så lime inn innholdet fra den gamle.
+
+`CardDeck`-klassen har du også implementert, og denne må også flyttes på samme måte som Card. Denne klassen skal utvides:
+
+- `deal(CardHand, int n)` - flytter n kort fra kortstokken (`CardDeck`-objektet) til korthånda (`CardHand`-objektet, som er første argument), ved å ta ett og ett kort med høyeste gyldige indeks, fjerne det fra `CardDeck`-objektet og legge det til `CardHand`-objektet.
+
+`CardHand` er en ny klasse som skal implementeres. `CardHand`-objekter inneholder initielt ingen kort, og klassen inneholder de samme standardmetodene som `CardDeck`, altså `getCardCount()` og `getCard(int)`, for å lese hvor mange og hvilke kort den inneholder. I tillegg har den to metoder for å endre tilstand:
+
+- `addCard(Card)` - legger argumentet til dette `CardHand`-objektet
+- `play(int n)` - returnerer og fjerner kort nr. n (første kort har nr. 0) fra dette `CardHand`-objektet (som om det ble spilt ut)
+
+**Java-kode**
+
+Utvid `CardDeck` og lag `CardHand` som beskrevet over. Test klassene med selvlagde main-metoder og ved å kjøre JUnit-testene.
+
+Testkode for denne oppgaven finner du her: [CardTest.java](../../src/test/java/oving4/CardTest.java), [CardDeckTest.java](../../src/test/java/oving4/CardDeckTest.java), [CardHandTest.java](../../src/test/java/oving4/CardHandTest.java).
diff --git a/ovinger/oppgavetekster/oving4/Partner.md b/ovinger/oppgavetekster/oving4/Partner.md
new file mode 100644
index 0000000000000000000000000000000000000000..24c7a329eba9f7031a0f31fc397c51efe337446c
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/Partner.md
@@ -0,0 +1,72 @@
+# Objektstrukturer - Partner-oppgave
+
+Denne oppgaven handler om en `Partner`-klasse med en [1-1-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-1-assosiasjoner)
+kalt partner tilbake til samme klasse (altså kjønnsnøytralt partnerskap)
+og det å sikre konsistens, slik at Partner-objekter er parvis knyttet sammen.
+
+En viktig del av det å implementere assosiasjoner er å sikre konsistens, dvs. at objekter i hver ende av en kobling refererer korrekt til
+hverandre. Et eksempel på dette for [1-1-assosiasjoner](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-1-assosiasjoner) er
+(kjønnsnøytralt) partnerskap, hvor to partnere er koblet til hverandre når partnerskap
+inngås og kobles fra hverandre ved en evt. skillsmisse. I denne oppgaven skal en `Partner`-klasse implementeres og ulike situasjoner håndteres
+korrekt, som illustrert nedenfor.
+
+`Partner`-klassen skal inneholde informasjon om _navn_ (en String), som bare skal kunne settes i konstruktøren, og _partneren_, som er et annet
+Partner-objekt. Navnet er ikke viktig for oppførselen, men er grei å ha med i en `toString()`-metode, for å skille Partner-objektene fra
+hverandre. `Partner`-klassen skal ha følgende metoder for å lese tilstanden:
+
+- `getName()` - returnerer navnet knyttet til dette Partner-objektet
+- `getPartner()` - returnerer Partner-objektet som er knyttet til dette Partner-objektet, evt. null, hvis partnerskap ikke er inngått
+
+`Partner`-klassen har kun én endringsmetode, `setPartner(Partner)`, som brukes både for å inngå partnerskap, når argumentet er et Partner-objekt,
+og oppløse det, når argumentet er null. List og figurene under illustrerer de tre tilfellene som må kunne håndteres, og som JUnit-testene sjekker.
+
+### 1. Inngåelse av partnerskap:
+
+**Kall**: p1.setPartner(p2)
+
+**Beskrivlse**: Partner-objektene p1 og p2 kobles sammen med ett kall til setPartner. Før kallet er p1 og p2 ikke koblet sammen,
+og etter kallet er det koblet sammen.
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 2. Oppløsning av partnerskap:
+
+**Kall**: p1.setPartner(null)
+
+**Beskrivlse**: Partner-objektene p1 og p2 kobles fra hverandre med ett kall til setPartner med null som argument.
+Før kallet er p1 og p2 koblet sammen, og etter kallet er det ikke lenger koblet sammen.
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 3. Oppløsning og inngåelse av partnerskap i ett:
+
+**Kall**: p1.setPartner(p3)
+
+**Beskrivlse**: Partner-objektene p1, p2, p3 og p4 er parvis koblet sammen, før ett kall til setPartner kobler
+sammen p1 og p3, mens p2 og p4 kobles fra deres tidligere partnere.
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+## Gjøremål
+
+Oppgaven er (enkelt og greit) å implementere `Partner`-klassen og sjekke (f.eks. med en `main`-metode) at Partner-objektene oppfører seg som de skal.
+
+Testkode for denne oppgaven finner du her: [oving4/PartnerTest.java](../../src/test/java/oving4/PartnerTest.java).
diff --git a/ovinger/oppgavetekster/oving4/Person.md b/ovinger/oppgavetekster/oving4/Person.md
new file mode 100644
index 0000000000000000000000000000000000000000..d60c3c34708fe85ad50828d0de640da430ca684b
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/Person.md
@@ -0,0 +1,151 @@
+# Objektstrukturer - Person-oppgave
+
+Denne oppgaven handler om en `Person`-klasse med en [1-n-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-n-assosiasjoner)
+med rollene _children_ og _mother_/_father_ til samme klasse (altså barn-mor/far-forhold) og det å sikre konsistens, slik at foreldre og barn
+er korrekt knyttet sammen.
+
+En viktig del av det å implementere assosiasjoner er å sikre konsistens, dvs. at objekter i hver ende av en kobling refererer korrekt
+til hverandre. Et eksempel på dette for [1-n-assosiasjoner](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-n-assosiasjoner) er
+foreldreskap, hvor foreldre og barn er koblet til samme i et slektstre. I denne oppgaven skal en `Person`-klasse implementeres og det å
+legge til (og fjerne) barn håndteres korrekt, som illustrert nedenfor.
+
+`Person`-klassen skal inneholde informasjon om _navn_ (en String) og _kjønn_ (en char, 'F' eller 'M'), som bare skal kunne settes i
+konstruktøren, og _mor_, _far_ og _barn_, som er andre Person-objekter. Navnet er ikke viktig for oppførselen, men er grei å ha med
+i en `toString()`-metode, for å skille Person-objektene fra hverandre. `Person`-klassen skal ha følgende metoder for å lese tilstanden:
+
+- `getName()` - returnerer navnet knyttet til dette Person-objektet
+- `getGender()` - returnerer tegnet som representerer kjønnet, enten 'F' eller 'M'
+- `getMother()` - returnerer Person-objektet som er moren, evt. `null`
+- `getFather()` - returnerer Person-objektet som er faren, evt. `null`
+- `getChildCount()` - returnerer antall barn dette Person-objektet har
+- `getChild(int n)` - returnerer barn nr. n (altså et Person-objekt), evt. utløser (et passende) unntak om `n` er for stor (eller liten)
+
+`Person`-klassen har to sett med endringsmetoder, knyttet til de to rollene i hver ende av _children_-_mother_/_father_-assosiasjonen.
+
+Fra _children_-perspektivet har vi følgende to metoder:
+
+- `addChild(Person)` - oppretter en kobling til et barn (et annet Person-objekt). Dersom Person-objektet som metoden kalles på, er
+ en _kvinne_, så skal denne bli barnets _mor_, og motsatt, dersom Person-objektet som metoden kalles på, er en _mann_, så skal denne
+ bli barnets _far_.
+- `removeChild(Person)` - fjerner en kobling til et barn (et annet Person-objekt). Dersom Person-objektet som metoden kalles på, er _moren_
+ til argumentet, så skal _mother_-koblingen fjernes, og motsatt, dersom Person-objektet som metoden kalles på, er argumentets _far_, så skal
+ _father_-koblingen fjernes.
+
+Fra _mother_/_father_-perspektivet har vi følgende to metoder:
+
+- `setMother(Person)` - setter argumentet (en kvinne) som _moren_ til Person-objektet som metoden kalles på. Argumentet får samtidig
+ registrert Person-objektet som metoden kalles på, som sitt _barn_.
+- `setFather(Person)` - setter argumentet (en mann) som _faren_ til Person-objektet som metoden kalles på. Argumentet får samtidig
+ registrert Person-objektet som metoden kalles på, som sitt _barn_.
+
+Det som er verd å merke seg er at begge sett med metoder, `addChild`/`removeChild` og `setMother`/`setFather`, må ha logikk
+som håndterer koblingen den andre veien, så `addChild`/`removeChild` må kalle `setMother`/`setFather` og omvendt, eller ha kode
+med tilsvarende effekt. Dette kan være nokså fiklete, fordi en både må sikre konsistens og unngå uendelig nøstede kall
+(inntil du får StackOverflowException).
+
+Listen og figurene under illustrerer de fem tilfellene som må kunne håndteres, og som testes av testene det er lenket til.
+
+### 1. Opprettelse av koblinger med `addChild`
+
+**Kall**:
+marit.addChild(jens)
+
+hallvard.addChild(jens)
+
+(Dette har samme effekt som kallene under punkt 2.)
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 2. Opprettelse av koblinger med `setMother` og `setFather`
+
+**Kall**:
+jens.setMother(marit)
+
+jens.setFather(hallvard)
+
+(Dette har samme effekt som kallene under punkt 1.)
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 3. Fjerning av koblinger med `removeChild`
+
+**Kall**:
+marit.removeChild(jens)
+
+hallvard.removeChild(jens)
+
+(Dette har samme effekt som kallene under punkt 4.)
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 4. Fjerning av koblinger med `setMother` og `setFather`
+
+**Kall**:
+jens.setMother(null)
+
+jens.setFather(null)
+
+(Dette har samme effekt som kallene under punkt 3.)
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+### 5. Fjerning og oppretting av kobling med `setMother` og `setFather`, en slags "adoption"
+
+**Kall**:
+jens.setFather(torkel)
+
+jens.setMother(jorunn)
+
+**Før kall**:
+
+
+
+**Etter kall**:
+
+
+
+## Oppgaven
+
+Oppgaven er delt i to trinn, den første håndterer _children_- og _mother_/_father_-rollen isolert og uten krav om konsistens,
+mens det andre skal sikre konsistens.
+
+### Del 1
+
+- Implementer `addChild`- og `removeChild`-metodene slik at `getChildCount`- og `getChild`-metodene virker som forventet.
+ Disse metodene håndterer altså kun _children_-rollen.
+- Implementer `setMother`- og `setFather`-metodene slik at `getMother`- og `getFather`-metodene virker som forventet.
+ Disse metodene håndteres altså kun _mother_/_father_-rollen.
+
+Test metodene ved å koble opp Person-objekter tilsvarende din egen familie. Du blir nødt til å bruke de tre metodene `addChild`, `setMother`
+og `setFather`. Prøv å få med minst tre generasjoner.
+
+### Del 2
+
+Utvid metodene til å sikre konsistens. Test at det fortsatt virker å koble opp din egen familie, denne gangen ved å bare bruke
+`addChild` og ved å bare bruke `setMother` og `setFather`. Kjør JUnit-testene som hører til oppgaven.
+
+Testkode for denne oppgaven finner du her: [oving4/PersonTest.java](../../src/test/java/oving4/PersonTest.java).
diff --git a/ovinger/oppgavetekster/oving4/README.md b/ovinger/oppgavetekster/oving4/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d71e24b7caa1171206144adbd848a715b2972100
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/README.md
@@ -0,0 +1,64 @@
+# Øving 4: Objektstrukturer
+
+**Øvingsmål**
+
+- Lære hva assosiasjoner er og hvordan dette brukes i OO
+- Lære hvordan man sikrer konsistent oppførsel mellom assosierte objekter
+
+**Øvingskrav**
+
+- Kunne implementere klasser som har assosiasjoner til én eller flere andre klasser
+- Kunne sikre at disse assosiasjon er konsistente i enkle objektstrukturer
+- Kunne implementere metoder som oppretter, oppdaterer og fjerner slike assosiasjoner
+
+## Dette må du gjøre
+
+### Del 1: Programmering
+
+I denne øvingen skal du velge og gjennomføre ENTEN både Partner- og Card del 2-oppgavene ELLER minst én av Twitter-, Stopwatch- og Person-oppgavene.
+Merk at **noen av oppgavene i neste øving (øving 5), bygger videre på noen av oppgavene under**, disse er uthevet med **fet skrift**.
+Det er ikke et krav at man gjør de uthevede oppgavene, men de gir flere oppgaver å velge mellom i øving 6.
+
+**Gjør enten _begge_ disse:**
+
+- [Partner](./Partner.md) (lett)
+- **[Card del 2](./Card.md)** (lett)
+
+**Eller _minst én_ av følgende oppgaver:**
+
+- **[Twitter](./Twitter.md)** (medium, men lang)
+- [Stopwatch](./Stopwatch.md) (medium)
+- [Person](./Person.md) (medium/vanskelig)
+
+Oppgavene for denne øvingen skal du lagre i `ovinger/src/main/java/oving4`. Test-filene ligger i `ovinger/src/test/java/oving4`.
+
+Alle oppgavene ovenfor er høyst eksamensrelevante og det anbefales å ta en titt på alle sammen.
+
+### Del 2: Klassediagram
+
+- Lag et [klassediagram](https://www.ntnu.no/wiki/display/tdt4100/Klassediagrammer) for en av oppgavene du velger. Husk å få med relasjonene mellom klassene.
+
+Diagrammet kan for eksempel skrives på papir eller tegnes/lages i et valgfritt program. Du trenger ikke levere inn diagrammene, men de skal vises til studass under godkjenning av øvingen.
+
+### Del 3: Testing
+
+Skriv kode som tester oppførselen til `CoffeeCup`-klassen, dvs. at du skal teste om metodene i listen under har rett oppførsel og returnerer det de skal, i tillegg til at du skal teste konstruktørene. Det er ikke nødvendig å teste absolutt alle mulige tilfeller, men det kreves at du tester den grunnleggende funksjonaliteten.
+
+- `getCapacity`
+- `getCurrentVolume`
+- `increaseCupSize`
+- `drinkCoffee`
+- `fillCoffee`
+
+Du finner `CoffeeCup`-klassen under `ovinger/src/main/java/oving4/testing`.
+
+Her er det anbefalt å bruke [JUnit](https://www.ntnu.no/wiki/display/tdt4100/Enhetstesting+med+JUnit),
+men det er lov å teste vha. main-metoden også. Dersom du bruker JUnit må du opprette testen i `oving/src/test/java/oving4/testing`.
+
+### Hjelp / mistanke om bugs
+
+Ved spørsmål eller behov for hjelp konsulter studassen din i saltiden hans / hennes. Du kan også oppsøke andre studasser på sal eller legge ut et innlegg på [Piazza](https://piazza.com/).
+
+### Godkjenning
+
+Last opp kildekode på Blackboard innen den angitte innleveringsfristen. Innlevert kode skal demonstreres for en læringsassistent innen én uke etter innleveringsfrist. Se for øvrig Blackboard-sidene for informasjon rundt organisering av øvingsopplegget og det tilhørende øvingsreglementet.
diff --git a/ovinger/oppgavetekster/oving4/Stopwatch.md b/ovinger/oppgavetekster/oving4/Stopwatch.md
new file mode 100644
index 0000000000000000000000000000000000000000..81af813cd31dc6aa7d5de56736519dd32a9b7388
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/Stopwatch.md
@@ -0,0 +1,30 @@
+# Objektstrukturer - StopWatchManager-oppgave
+
+Denne oppgaven handler om en `StopWatchManager`-klasse som inneholder flere `StopWatch`-objekter. Oppgaven bygger på klassen lagd i [StopWatch-oppgaven](../oving1/Stopwatch.md) fra "tilstand og oppførsel".
+
+I mange sammenhenger vil objekter av en klasse inneholde eller "eie" objekter av andre klasser. Når en klasse er assosiert med én instans av en (annen) klasse er dette en [1-1-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-1-assosiasjoner) og når en klasse er assosiert med flere instanser av en annen klasse er dette en [1-n-assosiasjon](https://www.ntnu.no/wiki/display/tdt4100/Koding+av+1-n-assosiasjoner).
+
+I denne oppgaven skal du implementere en `StopWatchManager`-klasse som kan holde styr på flere stoppeklokker. Ved hjelp av `StopWatchManager` skal man enkelt kunne holde styr på flere stoppeklokker og sørge for at alle stoppeklokker får beskjed om tiden som går. Dette kan være nyttig hvis man f.eks. ønsker å holde styr på flere løpere i et skirenn der ikke alle starter og fullfører samtidig, men hvor allikevel klokken må gå for alle.
+
+Det skal være mulig å opprette nye stoppeklokker med et tilhørende navn (streng). Navnet skal man senere kunne bruke til å hente stoppeklokken igjen eller fjerne stoppeklokken fra `StopWatchManager`. For å få til dette kan det være lurt å se litt på `Map` fra [Collection-rammeverket](https://www.ntnu.no/wiki/display/tdt4100/Collection-rammeverket).
+
+`StopWatchManager` skal ha følgende endringsmetoder:
+
+- `StopWatch newStopWatch(String name)` - Oppretter en ny stoppeklokke knyttet til navnet `name`. Returnerer den nye stoppeklokken.
+- `void removeStopWatch(String name)` - Fjerner stoppeklokken tilknyttet navnet `name`.
+- `void tick(int ticks)` - Informerer alle stoppeklokkene om at ticks tikk har gått.
+
+`StopWatchManager` skal ha følgende lesemetoder:
+
+- `StopWatch getStopWatch(String name)` - returnerer stoppeklokken tilknyttet navnet `name`.
+- `Collection<StopWatch> getAllWatches()` - returnerer alle stoppeklokkene.
+- `Collection<StopWatch> getStartedWatches()` - returnerer alle stoppeklokkene som er startet.
+- `Collection<StopWatch> getStoppedWatches()` - returnerer alle stoppeklokkene som er stoppet.
+
+**Merk**: Det er viktig at de metodene som returnerer en samling av stoppeklokker returnerer nye samlinger. De som får en samling må kunne endre på den (f.eks. fjerne elementer) uten at dette forstyrrer `StopWatchManager` eller andre som har fått samlinger tidligere.
+
+**Java-kode**
+
+Kopier `StopWatch` fra `encapsulation`-pakken og lag `StopWatchManager` som beskrevet over. Test klassen med selvlagde main-metoder og ved å kjøre JUnit-testene.
+
+Testkode for denne oppgaven finner du her: [oving4/StopWatchTest.java](../../src/test/java/oving4/StopWatchTest.java) og [oving4/StopWatchManagerTest.java](../../src/test/java/oving4/StopWatchManagerTest.java).
diff --git a/ovinger/oppgavetekster/oving4/Twitter.md b/ovinger/oppgavetekster/oving4/Twitter.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7a3c212ede1261b961e221cf2e181a9e5511421
--- /dev/null
+++ b/ovinger/oppgavetekster/oving4/Twitter.md
@@ -0,0 +1,73 @@
+# Objektstrukturer - Twitter-oppgave
+
+Denne oppgaven handler om en begrenset klone av `Twitter`, med to klasser, `TwitterAccount` og `Tweet`.
+
+En Twitter-konto kan følge andre Twitter-kontoer og motsatt: en Twitter-konto kan bli fulgt av andre Twitter-kontoer.
+Dette er altså en gjensidig kobling: Hvis konto A følger konto B, så er konto B fulgt av konto A. En kan selvsagt ikke følge seg selv.
+
+I tillegg har hver Twitter-konto en mengde _tweets_, som er små, korte tekster. En tweet hører til den kontoen den ble sendt fra.
+Hvis noen finner en annen sin tweet interessant har man muligheten til å retweete denne. Da lager man en tweet som refererer til originalen,
+og (implisitt) få original-tweeten sin tekst. Merk at i en kjede av retweets, så vil alle referere til samme original-tweet. Mao.,
+hvis tweet B er en retweet av A og tweet C er en retweet av B, vil både tweet B og C ha A som original-tweet, slik det er vist under.
+
+**Riktig objektstrutur**, når B er en retweet av A og C er en retweet av B:
+
+
+
+**Feil objektstrutur**, når B er en retweet av A og C er en retweet av B:
+
+
+
+## Tweet-klassen
+
+`Tweet` skal ha to konstruktører, en for hver måte å tweete på:
+
+- `Tweet(TwitterAccount, String)` - En ny original-tweet
+- `Tweet(TwitterAccount, Tweet)` - En retweet av Tweet-argumentet. Utløser et passende unntak, hvis original-tweeten er fra samme konto.
+
+`Tweet` skal ha metodene:
+
+- `String getText()` - returnerer teksten til en tweet
+- `TwitterAccount getOwner()` - returnerer kontoen som tweeten kom fra
+- `Tweet getOriginalTweet()` - returnerer original-tweeten, hvis den er en retweet, ellers null
+- `int getRetweetCount()` - returnerer antall ganger denne tweeten har blitt retweetet
+
+## TwitterAccount-klassen
+
+`TwitterAccount` skal ha konstruktøren:
+
+- `TwitterAccount(String)` - som tar inn brukernavnet
+
+`TwitterAccount` skal ha metodene:
+
+- `String getUserName()` - returnerer brukernavnet
+- `void follow(TwitterAccount account)` - denne (this) kontoen starter å følge account
+- `void unfollow(TwitterAccount account)` - slutt å følge account
+- `boolean isFollowing(TwitterAccount account)` - returnerer om denne kontoen følger account
+- `boolean isFollowedBy(TwitterAccount account)` - returnerer om account følger denne kontoen
+- `void tweet(String)` - lager en ny tweet for denne kontoen
+- `void retweet(Tweet tweet)` - retweeter tweet fra denne kontoen
+- `Tweet getTweet(int i)` - returner tweet nummer i, der 1 er den nyeste, 2 den nest nyeste, … (merk rekkefølgen!)
+- `int getTweetCount()` - returner antall tweets til kontoen
+- `int getRetweetCount()` - returner antall retweets av tweets fra denne kontoen
+
+## Del 1
+
+- Implementer `Tweet`-klassen.
+- For å teste klassen må du sende inn TwitterAccount-objekter i konstruktøren. Lag en forenklet versjon av `TwitterAccount`-klassen
+ for dette formålet, der du kun implementerer konstruktøren og evt. en passende toString(). Dette gjør det mulig å teste `Tweet`-klassen
+ din uten at du må implementere hele `TwitterAccount`-klassen først.
+
+## Del 2
+
+- Implementer `TwitterAccount`-klassen.
+- Test klassen og dens samspill med `Tweet`-klassen ved å lage Twitter-konto for deg selv og noen av vennene dine.
+ La noen av kontoene følge hverandre, tweete og retweete.
+
+Testkode for denne oppgaven finner du her: [oving4/TweetTest.java](../../src/test/java/oving4/TweetTest.java) og [oving4/TwitterAccountTest.java](../../src/test/java/oving4/TwitterAccountTest.java).
+
+## Frivillig utvidelse
+
+På Twitter kan man markere en annen sin tweet som en favoritt. Implementer passende metoder for å kunne gjøre dette.
+En konto må ha oversikt over hvilke tweets den har markert som favoritter, og en tweet må vite hvem og hvor mange som har markert den
+som favoritt. Hva synes du burde skje hvis man markerer en retweet som en favoritt?
diff --git a/ovinger/oppgavetekster/oving4/img/partner1.png b/ovinger/oppgavetekster/oving4/img/partner1.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b7c698197784f81f82ba8bed1faf023e2c30d98
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/partner1.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/partner2.png b/ovinger/oppgavetekster/oving4/img/partner2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c87f953b420183e352fdaad3d2eb70ae73565135
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/partner2.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/partner3.png b/ovinger/oppgavetekster/oving4/img/partner3.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ef5c3d172750f3a1027a6d6917174d4a7d153dc
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/partner3.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/partner4.png b/ovinger/oppgavetekster/oving4/img/partner4.png
new file mode 100644
index 0000000000000000000000000000000000000000..cac8b48120b7452ba252be710e1097a6cf27fa09
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/partner4.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/person1.png b/ovinger/oppgavetekster/oving4/img/person1.png
new file mode 100644
index 0000000000000000000000000000000000000000..05310b6347212fa41833501d4fb44f485525cd43
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/person1.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/person2.png b/ovinger/oppgavetekster/oving4/img/person2.png
new file mode 100644
index 0000000000000000000000000000000000000000..1648e1a6fe0dbe1973539656c74d10a0bb36e811
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/person2.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/person3.png b/ovinger/oppgavetekster/oving4/img/person3.png
new file mode 100644
index 0000000000000000000000000000000000000000..5b045b9cabd8d93f5eb5095f8017c913f912e5f5
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/person3.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/person4.png b/ovinger/oppgavetekster/oving4/img/person4.png
new file mode 100644
index 0000000000000000000000000000000000000000..40afaba25025e4aa365bd84ab2fabddc7c72ab36
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/person4.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/twitter1.png b/ovinger/oppgavetekster/oving4/img/twitter1.png
new file mode 100644
index 0000000000000000000000000000000000000000..2d3e1f139b5200d614180cdcba3ed8d424aa2b4c
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/twitter1.png differ
diff --git a/ovinger/oppgavetekster/oving4/img/twitter2.png b/ovinger/oppgavetekster/oving4/img/twitter2.png
new file mode 100644
index 0000000000000000000000000000000000000000..27927b01fa0ed88f385d177401c6fad76857c781
Binary files /dev/null and b/ovinger/oppgavetekster/oving4/img/twitter2.png differ
diff --git a/ovinger/src/main/java/oving4/.gitinclude b/ovinger/src/main/java/oving4/.gitinclude
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ovinger/src/main/java/oving4/testing/CoffeeCup.java b/ovinger/src/main/java/oving4/testing/CoffeeCup.java
new file mode 100644
index 0000000000000000000000000000000000000000..583e9c4a86cb00bd0548a193af43bfba2c37fa59
--- /dev/null
+++ b/ovinger/src/main/java/oving4/testing/CoffeeCup.java
@@ -0,0 +1,82 @@
+package oving4.testing;
+
+public class CoffeeCup {
+
+ private double capacity;
+ private double currentVolume;
+
+ public CoffeeCup() {
+ this.capacity = 0.0;
+ this.currentVolume = 0.0;
+ }
+
+ public CoffeeCup(double capacity, double currentVolume) {
+ if (isValidCapacity(capacity)) {
+ this.capacity = capacity;
+ } else {
+ throw new IllegalArgumentException("Illegal capacity given.");
+ }
+ if (isValidVolume(currentVolume)) {
+ this.currentVolume = currentVolume;
+ } else {
+ throw new IllegalArgumentException("Illegal volume given.");
+ }
+ }
+
+ public double getCapacity() {
+ return capacity;
+ }
+
+ public double getCurrentVolume() {
+ return currentVolume;
+ }
+
+ public void increaseCupSize(double biggerCapacity) {
+ if (isValidCapacity(biggerCapacity)) {
+ this.capacity += biggerCapacity;
+ }
+ }
+
+ private boolean isValidVolume(double volume) {
+ if (volume > this.capacity || volume < 0.0) {
+ return false;
+ }
+ return true;
+ }
+
+ private boolean canDrink(double volume) {
+ if (this.currentVolume >= volume) {
+ return true;
+ }
+ return false;
+ }
+
+ public void drinkCoffee(double volume) {
+ if (isValidVolume(volume) && canDrink(volume)) {
+ this.currentVolume -= volume;
+ } else {
+ throw new IllegalArgumentException("You can't drink that much coffee!");
+ }
+ }
+
+ public void fillCoffee(double volume) {
+ if (isValidVolume(this.currentVolume + volume)) {
+ this.currentVolume += volume;
+ } else {
+ throw new IllegalArgumentException("You just poured coffee all over the table. Good job.");
+ }
+ }
+
+ private boolean isValidCapacity(double capacity) {
+ if (capacity >= 0.0) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return "CoffeeCup [capacity=" + capacity + ", currentVolume=" + currentVolume + "]";
+ }
+
+}
diff --git a/ovinger/src/test/java/oving4/CardDeckTest.java b/ovinger/src/test/java/oving4/CardDeckTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..44a4a995517433e927883c1a80257baa1f359adb
--- /dev/null
+++ b/ovinger/src/test/java/oving4/CardDeckTest.java
@@ -0,0 +1,54 @@
+package oving4;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class CardDeckTest {
+
+ private CardDeck cardDeck;
+
+ private void checkDeck(CardDeck deck, String deckAsString) {
+ Collection<String> toStrings = Arrays.asList(deckAsString.split(","));
+ Assertions.assertEquals(toStrings.size(), deck.getCardCount(), "CardDeck har ikke korrekt størrelse");
+ int i = 0;
+ for (String toString : toStrings) {
+ Card card = deck.getCard(i);
+ String cardString = String.valueOf(card.getSuit()) + card.getFace();
+ Assertions.assertEquals(toString, cardString,
+ String.format("Card på plass %d var feil. CardDeck skulle vært %s", i + 1, toStrings));
+ i++;
+ }
+ }
+
+ @BeforeEach
+ public void setup() {
+ cardDeck = new CardDeck(2);
+ }
+
+ @Test
+ @DisplayName("Sjekk at Deck blir initialisert til to S1,S2,H1,H2,D1,D2,C1,C2")
+ public void testConstructor() {
+ checkDeck(cardDeck, "S1,S2,H1,H2,D1,D2,C1,C2");
+ }
+
+ @Test
+ @DisplayName("Sjekk at CardDeck blir stokket til S1,D1,S2,D2,H1,C1,H2,C2")
+ public void testShufflePerfectly() {
+ cardDeck.shufflePerfectly();
+ checkDeck(cardDeck, "S1,D1,S2,D2,H1,C1,H2,C2");
+ }
+
+ @Test
+ @DisplayName("Sjekk at deal gir ut de tre siste kortene")
+ public void testDeal() {
+ CardHand hand = new CardHand();
+ cardDeck.deal(hand, 3);
+ checkDeck(cardDeck, "S1,S2,H1,H2,D1");
+ }
+
+}
diff --git a/ovinger/src/test/java/oving4/CardHandTest.java b/ovinger/src/test/java/oving4/CardHandTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ee27932a767961d810ba6b4c4de0a3d1dda1568
--- /dev/null
+++ b/ovinger/src/test/java/oving4/CardHandTest.java
@@ -0,0 +1,54 @@
+package oving4;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class CardHandTest {
+ private CardHand cardHand;
+
+ @BeforeEach
+ public void setup() {
+ cardHand = new CardHand();
+ }
+
+ @Test
+ @DisplayName("Sjekk at konstruktøren lager en tom CardHand")
+ void testConstructor() {
+ CardDeck deck = new CardDeck(2);
+ deck.deal(cardHand, 3);
+ checkHand(cardHand, "C2,C1,D2");
+ }
+
+ @Test
+ @DisplayName("Test deal- og play-metodene")
+ void testDealPlay() {
+ CardDeck deck = new CardDeck(2);
+ deck.deal(cardHand, 3);
+ checkHand(cardHand, "C2,C1,D2");
+ cardHand.play(1);
+ checkHand(cardHand, "C2,D2");
+ cardHand.play(0);
+ checkHand(cardHand, "D2");
+ cardHand.play(0);
+ assertEquals(cardHand.getCardCount(), 0);
+ }
+
+ private void checkHand(CardHand hand, String deckAsString) {
+ Collection<String> toStrings = Arrays.asList(deckAsString.split(","));
+ assertEquals(toStrings.size(), hand.getCardCount(), "Det var feil antall kort på hånda");
+ int i = 0;
+ for (String toString : toStrings) {
+ Card card = hand.getCard(i);
+ String cardString = String.valueOf(card.getSuit()) + card.getFace();
+ assertEquals(toString, cardString,
+ String.format("Kortet på plass %d var feil. Hånda skulle inneholdt %s.", i + 1, toStrings));
+ i++;
+ }
+ }
+}
\ No newline at end of file
diff --git a/ovinger/src/test/java/oving4/CardTest.java b/ovinger/src/test/java/oving4/CardTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..450953819654ff84b691535b7edd19a5f4fbf59d
--- /dev/null
+++ b/ovinger/src/test/java/oving4/CardTest.java
@@ -0,0 +1,45 @@
+package oving4;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class CardTest {
+
+ private void checkCard(Card card, char suit, int face) {
+ Assertions.assertEquals(card.getSuit(), suit);
+ Assertions.assertEquals(card.getFace(), face);
+ }
+
+ @Test
+ @DisplayName("Sjekk at konstruktøren oppretter Card-objekter med riktige verdier")
+ public void testConstructor() {
+ checkCard(new Card('S', 1), 'S', 1);
+ checkCard(new Card('S', 13), 'S', 13);
+ checkCard(new Card('H', 1), 'H', 1);
+ checkCard(new Card('H', 13), 'H', 13);
+ checkCard(new Card('D', 1), 'D', 1);
+ checkCard(new Card('D', 13), 'D', 13);
+ checkCard(new Card('C', 1), 'C', 1);
+ checkCard(new Card('C', 13), 'C', 13);
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ new Card('X', 1);
+ }, "Skal ikke kunne lage et kort av typen X");
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ new Card('S', 0);
+ }, "Skal ikke kunne lage et kort med verdi 0");
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ new Card('C', 14);
+ }, "Skal ikke kunne lage et kort med verdi 14");
+ }
+
+ @Test
+ @DisplayName("Sjekk at toString fungerer som forventet")
+ public void testToString() {
+ Assertions.assertEquals("S1", new Card('S', 1).toString());
+ Assertions.assertEquals("H13", new Card('H', 13).toString());
+ }
+}
diff --git a/ovinger/src/test/java/oving4/PartnerTest.java b/ovinger/src/test/java/oving4/PartnerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7452f9e1407cba0a94dec6abc474cb9d979d445
--- /dev/null
+++ b/ovinger/src/test/java/oving4/PartnerTest.java
@@ -0,0 +1,71 @@
+package oving4;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class PartnerTest {
+
+ private Partner p1;
+ private Partner p2;
+
+ @BeforeEach
+ public void setup() {
+ p1 = new Partner("1");
+ p2 = new Partner("2");
+ }
+
+ @Test
+ @DisplayName("Sjekk konstruktøren ikke oppretter noen partnere")
+ public void testConstructor() {
+ assertNull(p1.getPartner());
+ assertNull(p2.getPartner());
+ }
+
+ @Test
+ @DisplayName("Sjekk at p1 og p2 er partnere etter p1.setPartner(s2)")
+ public void simplePartnerShip() {
+ // Enkelt partnerskap
+ assertNull(p1.getPartner());
+ assertNull(p2.getPartner());
+ p1.setPartner(p2);
+ assertEquals(p1.getPartner(), p2, "P1 skulle vært partneren til p2");
+ assertEquals(p2.getPartner(), p1, "P2 skulle vært partneren til p1");
+ }
+
+ @Test
+ @DisplayName("Sjekk at man kan oppløse partnerskap")
+ public void partnershipWithDivorce() {
+ // Partnerskap med etterfølgende brudd
+ p1.setPartner(p2);
+ assertEquals(p1.getPartner(), p2, "P1 skulle vært partneren til p2");
+ assertEquals(p2.getPartner(), p1, "P2 skulle vært partneren til p1");
+ p1.setPartner(null);
+ assertNull(p1.getPartner());
+ assertNull(p2.getPartner());
+ }
+
+ @Test
+ @DisplayName("Sjekk at kombinert brudd med påfølgende opprettelse av nytt partnerskap fungerer")
+ void swinger() {
+ // "Partnerskap med etterfølgende kombinert brudd og nytt partnerskap"
+ Partner p3 = new Partner("3");
+ Partner p4 = new Partner("4");
+ // Partnerskap inngås
+ p1.setPartner(p2);
+ p3.setPartner(p4);
+ assertEquals(p1.getPartner(), p2, "P1 skulle vært partneren til p2");
+ assertEquals(p2.getPartner(), p1, "P2 skulle vært partneren til p1");
+ assertEquals(p3.getPartner(), p4, "P3 skulle vært partneren til p4");
+ assertEquals(p4.getPartner(), p3, "P4 skulle vært partneren til p3");
+ // Kombinert brudd og nytt partnerskap
+ p1.setPartner(p4);
+ assertEquals(p1.getPartner(), p4, "P4 skulle vært partneren til p1");
+ assertEquals(p4.getPartner(), p1, "P1 skulle vært partneren til p4");
+ assertNull(p2.getPartner());
+ assertNull(p3.getPartner());
+ }
+}
diff --git a/ovinger/src/test/java/oving4/PersonTest.java b/ovinger/src/test/java/oving4/PersonTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb656da8673bf7bfa9c2f4eeb4cf59f30c612dae
--- /dev/null
+++ b/ovinger/src/test/java/oving4/PersonTest.java
@@ -0,0 +1,282 @@
+package oving4;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+public class PersonTest {
+
+ private Person hallvard, marit, jens, anne;
+
+ private void hasChildren(Person person, Collection<Person> children) {
+ Assertions.assertEquals(children.size(), person.getChildCount());
+
+ for (Person child : children) {
+ boolean found = false;
+ int i = 0;
+ while (i < person.getChildCount()) {
+ if (child == person.getChild(i)) {
+ found = true;
+ }
+ i++;
+ }
+ Assertions.assertTrue(found);
+ }
+ }
+
+ @BeforeEach
+ public void setup() {
+ hallvard = new Person("Hallvard", 'M');
+ marit = new Person("Marit", 'F');
+ jens = new Person("Jens", 'M');
+ anne = new Person("Anne", 'F');
+ }
+
+ @Test
+ @DisplayName("Kvinne kan ikke være far")
+ public void testFatherException() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ jens.setFather(marit);
+ });
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ anne.setFather(marit);
+ });
+ }
+
+ @Test
+ @DisplayName("Mann kan ikke være mor")
+ public void testMotherException() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ jens.setMother(hallvard);
+ });
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ anne.setMother(hallvard);
+ });
+ }
+
+ @Test
+ @DisplayName("Mann kan ikke være sin egen far")
+ public void testSelfFatherException() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ jens.setFather(jens);
+ });
+ }
+
+ @Test
+ @DisplayName("Kvinne kan ikke være sin egen mor")
+ public void testSelfMotherException() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ anne.setMother(anne);
+ });
+ }
+
+ @Test
+ @DisplayName("Sette farskap med setFather")
+ public void testSetFather() {
+ jens.setFather(hallvard);
+
+ // Check state of hallvard
+ Assertions.assertEquals(null, hallvard.getFather());
+ Assertions.assertEquals(null, hallvard.getMother());
+ hasChildren(hallvard, Arrays.asList(jens));
+
+ // Check state of jens
+ Assertions.assertEquals(hallvard, jens.getFather());
+ Assertions.assertEquals(null, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ anne.setFather(hallvard);
+
+ // Check state of hallvard
+ Assertions.assertEquals(null, hallvard.getFather());
+ Assertions.assertEquals(null, hallvard.getMother());
+ hasChildren(hallvard, Arrays.asList(jens, anne));
+
+ // Check state of jens
+ Assertions.assertEquals(hallvard, jens.getFather());
+ Assertions.assertEquals(null, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ // Check state of anne
+ Assertions.assertEquals(hallvard, anne.getFather());
+ Assertions.assertEquals(null, anne.getMother());
+ Assertions.assertEquals(0, anne.getChildCount());
+ }
+
+ @Test
+ @DisplayName("Sette farskap med addChild")
+ public void testFatherAddChild() {
+ hallvard.addChild(jens);
+
+ // Check state of hallvard
+ Assertions.assertEquals(null, hallvard.getFather());
+ Assertions.assertEquals(null, hallvard.getMother());
+ hasChildren(hallvard, Arrays.asList(jens));
+
+ // Check state of jens
+ Assertions.assertEquals(hallvard, jens.getFather());
+ Assertions.assertEquals(null, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ hallvard.addChild(anne);
+
+ // Check state of hallvard
+ Assertions.assertEquals(null, hallvard.getFather());
+ Assertions.assertEquals(null, hallvard.getMother());
+ hasChildren(hallvard, Arrays.asList(jens, anne));
+
+ // Check state of jens
+ Assertions.assertEquals(hallvard, jens.getFather());
+ Assertions.assertEquals(null, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ // Check state of anne
+ Assertions.assertEquals(hallvard, anne.getFather());
+ Assertions.assertEquals(null, anne.getMother());
+ Assertions.assertEquals(0, anne.getChildCount());
+ }
+
+ @Test
+ @DisplayName("Sette morskap med setMother")
+ public void testSetMother() {
+ jens.setMother(marit);
+
+ // Check state of marit
+ Assertions.assertEquals(null, marit.getFather());
+ Assertions.assertEquals(null, marit.getMother());
+ hasChildren(marit, Arrays.asList(jens));
+
+ // Check state of jens
+ Assertions.assertEquals(null, jens.getFather());
+ Assertions.assertEquals(marit, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ anne.setMother(marit);
+
+ // Check state of marit
+ Assertions.assertEquals(null, marit.getFather());
+ Assertions.assertEquals(null, marit.getMother());
+ hasChildren(marit, Arrays.asList(jens, anne));
+
+ // Check state of jens
+ Assertions.assertEquals(null, jens.getFather());
+ Assertions.assertEquals(marit, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ // Check state of anne
+ Assertions.assertEquals(null, anne.getFather());
+ Assertions.assertEquals(marit, anne.getMother());
+ Assertions.assertEquals(0, anne.getChildCount());
+ }
+
+ @Test
+ @DisplayName("Sette morskap med addChild")
+ public void testMotherAddChild() {
+ marit.addChild(jens);
+
+ // Check state of marit
+ Assertions.assertEquals(null, marit.getFather());
+ Assertions.assertEquals(null, marit.getMother());
+ hasChildren(marit, Arrays.asList(jens));
+
+ // Check state of jens
+ Assertions.assertEquals(null, jens.getFather());
+ Assertions.assertEquals(marit, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ marit.addChild(anne);
+
+ // Check state of marit
+ Assertions.assertEquals(null, marit.getFather());
+ Assertions.assertEquals(null, marit.getMother());
+ hasChildren(marit, Arrays.asList(jens, anne));
+
+ // Check state of jens
+ Assertions.assertEquals(null, jens.getFather());
+ Assertions.assertEquals(marit, jens.getMother());
+ Assertions.assertEquals(0, jens.getChildCount());
+
+ // Check state of anne
+ Assertions.assertEquals(null, anne.getFather());
+ Assertions.assertEquals(marit, anne.getMother());
+ Assertions.assertEquals(0, anne.getChildCount());
+ }
+
+ @Test
+ @DisplayName("Endre far med setFather")
+ public void testChangeFatherSetFather() {
+ anne.setFather(jens);
+ // Check state of anne
+ Assertions.assertEquals(jens, anne.getFather());
+ // Check state of jens
+ hasChildren(jens, Arrays.asList(anne));
+
+ anne.setFather(hallvard);
+ // Check state of anne
+ Assertions.assertEquals(hallvard, anne.getFather());
+ // Check state of jens
+ Assertions.assertEquals(0, jens.getChildCount());
+ // Check state of hallvard
+ hasChildren(hallvard, Arrays.asList(anne));
+ }
+
+ @Test
+ @DisplayName("Endre far med addChild")
+ public void testChangeFatherAddChild() {
+ jens.addChild(anne);
+ // Check state of anne
+ Assertions.assertEquals(jens, anne.getFather());
+ // Check state of jens
+ hasChildren(jens, Arrays.asList(anne));
+
+ hallvard.addChild(anne);
+ // Check state of anne
+ Assertions.assertEquals(hallvard, anne.getFather());
+ // Check state of jens
+ Assertions.assertEquals(0, jens.getChildCount());
+ // Check state of hallvard
+ hasChildren(hallvard, Arrays.asList(anne));
+ }
+
+ @Test
+ @DisplayName("Endre morskap med setMother")
+ public void testChangeMotherSetMother() {
+ jens.setMother(anne);
+ // Check state of jens
+ Assertions.assertEquals(anne, jens.getMother());
+ // Check state of anne
+ hasChildren(anne, Arrays.asList(jens));
+
+ jens.setMother(marit);
+ // Check state of jens
+ Assertions.assertEquals(marit, jens.getMother());
+ // Check state of anne
+ Assertions.assertEquals(0, anne.getChildCount());
+ // Check state of marit
+ hasChildren(marit, Arrays.asList(jens));
+ }
+
+ @Test
+ @DisplayName("Endre morskap med addChild")
+ public void testChangeMotherAddChild() {
+ anne.addChild(jens);
+ // Check state of jens
+ Assertions.assertEquals(anne, jens.getMother());
+ // Check state of anne
+ hasChildren(anne, Arrays.asList(jens));
+
+ marit.addChild(jens);
+ // Check state of jens
+ Assertions.assertEquals(marit, jens.getMother());
+ // Check state of anne
+ Assertions.assertEquals(0, anne.getChildCount());
+ // Check state of marit
+ hasChildren(marit, Arrays.asList(jens));
+ }
+}
diff --git a/ovinger/src/test/java/oving4/StopWatchManagerTest.java b/ovinger/src/test/java/oving4/StopWatchManagerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9c9c5b7a64e268ae7407d0fc4a826b5c0bce79f
--- /dev/null
+++ b/ovinger/src/test/java/oving4/StopWatchManagerTest.java
@@ -0,0 +1,101 @@
+package oving4;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+
+public class StopWatchManagerTest {
+
+ private StopWatchManager manager;
+
+ @BeforeEach
+ public void setup() {
+ manager = new StopWatchManager();
+ }
+
+ @Test
+ @DisplayName("Lage ny stoppeklokke")
+ public void testNewStopWatch() {
+ StopWatch sw1 = manager.newStopWatch("SW1");
+ StopWatch sw2 = manager.newStopWatch("SW2");
+ Assertions.assertEquals(sw1, manager.getStopWatch("SW1"));
+ Assertions.assertEquals(sw2, manager.getStopWatch("SW2"));
+ }
+
+ @Test
+ @DisplayName("Ticker")
+ public void testTicks() {
+ StopWatch sw1 = manager.newStopWatch("SW1");
+ StopWatch sw2 = manager.newStopWatch("SW2");
+
+ manager.tick(1);
+ Assertions.assertEquals(1, sw1.getTicks());
+ Assertions.assertEquals(1, sw2.getTicks());
+
+ manager.tick(4);
+ Assertions.assertEquals(5, sw1.getTicks());
+ Assertions.assertEquals(5, sw2.getTicks());
+ }
+
+ @Test
+ @DisplayName("Fjerne stoppeklokke")
+ public void testRemoveStopWatches() {
+ Assertions.assertEquals(0, manager.getAllWatches().size());
+
+ StopWatch sw1 = manager.newStopWatch("SW1");
+ Assertions.assertEquals(1, manager.getAllWatches().size());
+ Assertions.assertEquals(sw1, manager.getStopWatch("SW1"));
+
+ StopWatch sw2 = manager.newStopWatch("SW2");
+ Assertions.assertEquals(2, manager.getAllWatches().size());
+ Assertions.assertEquals(sw1, manager.getStopWatch("SW1"));
+ Assertions.assertEquals(sw2, manager.getStopWatch("SW2"));
+
+ manager.removeStopWatch("SW1");
+ Assertions.assertEquals(1, manager.getAllWatches().size());
+ Assertions.assertEquals(null, manager.getStopWatch("SW1"));
+
+ manager.removeStopWatch("SW2");
+ Assertions.assertEquals(0, manager.getAllWatches().size());
+ Assertions.assertEquals(null, manager.getStopWatch("SW1"));
+ Assertions.assertEquals(null, manager.getStopWatch("SW2"));
+ }
+
+ @Test
+ @DisplayName("Starte og stoppe klokker")
+ public void testStartedStoppedWatches() {
+ Assertions.assertEquals(0, manager.getStartedWatches().size());
+
+ manager.newStopWatch("SW1").start();
+ Assertions.assertEquals(1, manager.getStartedWatches().size());
+ Assertions.assertEquals(0, manager.getStoppedWatches().size());
+ Assertions.assertTrue(manager.getStartedWatches().contains(manager.getStopWatch("SW1")));
+ Assertions.assertTrue(manager.getStopWatch("SW1").isStarted());
+
+ manager.newStopWatch("SW2").start();
+ Assertions.assertEquals(2, manager.getStartedWatches().size());
+ Assertions.assertEquals(0, manager.getStoppedWatches().size());
+ Assertions.assertTrue(manager.getStartedWatches().contains(manager.getStopWatch("SW1")));
+ Assertions.assertTrue(manager.getStopWatch("SW1").isStarted());
+ Assertions.assertFalse(manager.getStopWatch("SW1").isStopped());
+ Assertions.assertTrue(manager.getStartedWatches().contains(manager.getStopWatch("SW2")));
+ Assertions.assertTrue(manager.getStopWatch("SW2").isStarted());
+ Assertions.assertFalse(manager.getStopWatch("SW2").isStopped());
+
+ manager.getStopWatch("SW2").stop();
+ Assertions.assertEquals(1, manager.getStoppedWatches().size());
+ Assertions.assertFalse(manager.getStoppedWatches().contains(manager.getStopWatch("SW1")));
+ Assertions.assertFalse(manager.getStopWatch("SW1").isStopped());
+ Assertions.assertTrue(manager.getStoppedWatches().contains(manager.getStopWatch("SW2")));
+ Assertions.assertTrue(manager.getStopWatch("SW2").isStopped());
+
+ manager.getStopWatch("SW1").stop();
+ Assertions.assertEquals(2, manager.getStoppedWatches().size());
+ Assertions.assertTrue(manager.getStoppedWatches().contains(manager.getStopWatch("SW1")));
+ Assertions.assertTrue(manager.getStopWatch("SW1").isStopped());
+ Assertions.assertTrue(manager.getStoppedWatches().contains(manager.getStopWatch("SW2")));
+ Assertions.assertTrue(manager.getStopWatch("SW2").isStopped());
+ }
+
+}
diff --git a/ovinger/src/test/java/oving4/StopWatchTest.java b/ovinger/src/test/java/oving4/StopWatchTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..40cdba69ab28a5115d40d2f8c0648be7cd3fe744
--- /dev/null
+++ b/ovinger/src/test/java/oving4/StopWatchTest.java
@@ -0,0 +1,154 @@
+package oving4;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class StopWatchTest {
+
+ private StopWatch stopWatch;
+
+ @BeforeEach
+ public void beforeEach() {
+ stopWatch = new StopWatch();
+ }
+
+ @Test
+ @DisplayName("Sjekk at et nyopprettet StopWatch-objekt har korrekte verdier")
+ public void testConstructor() {
+ Assertions.assertFalse(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+ Assertions.assertEquals(0, stopWatch.getTicks());
+ Assertions.assertEquals(-1, stopWatch.getTime());
+ Assertions.assertEquals(-1, stopWatch.getLapTime());
+ Assertions.assertEquals(-1, stopWatch.getLastLapTime());
+ }
+
+ @Test
+ @DisplayName("Sjekk at tick() uten start ikke endrer tiden")
+ public void testTicksWithoutStart() {
+ stopWatch.tick(1);
+ Assertions.assertEquals(-1, stopWatch.getTime());
+ Assertions.assertEquals(1, stopWatch.getTicks());
+ stopWatch.tick(4);
+ Assertions.assertEquals(-1, stopWatch.getTime());
+ Assertions.assertEquals(5, stopWatch.getTicks());
+ }
+
+ @Test
+ @DisplayName("Start og stopp klokken og sjekk at tiden er riktig")
+ public void testStartTickStop() {
+ stopWatch.start();
+ Assertions.assertEquals(0, stopWatch.getTime());
+ Assertions.assertEquals(0, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ Assertions.assertThrows(IllegalStateException.class, () -> {
+ stopWatch.start();
+ }, "Cannot start already running stopwatch");
+
+ stopWatch.tick(3);
+ Assertions.assertEquals(3, stopWatch.getTime());
+ Assertions.assertEquals(3, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.tick(5);
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(8, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.stop();
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(8, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertTrue(stopWatch.isStopped());
+
+ Assertions.assertThrows(IllegalStateException.class, () -> {
+ stopWatch.stop();
+ }, "Skal ikke kunne stoppe en klokke som allerede er stoppet");
+ }
+
+ @Test
+ @DisplayName("Start og stopp klokken, og kall tick() mens den ikke er startet")
+ public void testTickStartTickStopTick() {
+ stopWatch.tick(2);
+ Assertions.assertEquals(-1, stopWatch.getTime());
+ Assertions.assertEquals(2, stopWatch.getTicks());
+ Assertions.assertFalse(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.start();
+ Assertions.assertEquals(0, stopWatch.getTime());
+ Assertions.assertEquals(2, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.tick(3);
+ Assertions.assertEquals(3, stopWatch.getTime());
+ Assertions.assertEquals(5, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.tick(5);
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(10, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertFalse(stopWatch.isStopped());
+
+ stopWatch.stop();
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(10, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertTrue(stopWatch.isStopped());
+
+ stopWatch.tick(3);
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(13, stopWatch.getTicks());
+ Assertions.assertTrue(stopWatch.isStarted());
+ Assertions.assertTrue(stopWatch.isStopped());
+
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ stopWatch.tick(-1);
+ }, "Tiden skal ikke kunne gå bakover");
+ }
+
+ @Test
+ @DisplayName("Sjekk at laps funker som forventet")
+ public void testLaps() {
+ Assertions.assertThrows(IllegalStateException.class, () -> {
+ stopWatch.lap();
+ }, "Skal ikke kunne starte en ny runde uten å starte klokken");
+ stopWatch.start();
+ Assertions.assertEquals(0, stopWatch.getTime());
+ Assertions.assertEquals(0, stopWatch.getLapTime());
+ Assertions.assertEquals(-1, stopWatch.getLastLapTime());
+
+ stopWatch.tick(3);
+ Assertions.assertEquals(3, stopWatch.getTime());
+ Assertions.assertEquals(3, stopWatch.getLapTime());
+ Assertions.assertEquals(-1, stopWatch.getLastLapTime());
+
+ stopWatch.lap();
+ Assertions.assertEquals(3, stopWatch.getTime());
+ Assertions.assertEquals(0, stopWatch.getLapTime());
+ Assertions.assertEquals(3, stopWatch.getLastLapTime());
+
+ stopWatch.tick(5);
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(5, stopWatch.getLapTime());
+ Assertions.assertEquals(3, stopWatch.getLastLapTime());
+
+ stopWatch.stop();
+ Assertions.assertEquals(8, stopWatch.getTime());
+ Assertions.assertEquals(0, stopWatch.getLapTime());
+ Assertions.assertEquals(5, stopWatch.getLastLapTime());
+ Assertions.assertThrows(IllegalStateException.class, () -> {
+ stopWatch.lap();
+ }, "Skal ikke kunne starte en ny runde med en stoppet klokke");
+ }
+
+}
diff --git a/ovinger/src/test/java/oving4/TweetTest.java b/ovinger/src/test/java/oving4/TweetTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..96062b36bd7359792ac645d76957250ca9beef23
--- /dev/null
+++ b/ovinger/src/test/java/oving4/TweetTest.java
@@ -0,0 +1,66 @@
+package oving4;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class TweetTest {
+ TwitterAccount nils;
+ TwitterAccount ole;
+ TwitterAccount kari;
+ Tweet tweet, retweet1, retweet2;
+
+ @BeforeEach
+ public void setup() {
+ nils = new TwitterAccount("Nils");
+ ole = new TwitterAccount("Ole");
+ kari = new TwitterAccount("Kari");
+
+ tweet = new Tweet(nils, "Kvitre!");
+ retweet1 = null;
+ retweet2 = null;
+ }
+
+ @Test
+ void constructorNewTweet() {
+ assertEquals("Kvitre!", tweet.getText(), "Konstruktøren initialiserte tweeten med feil tekst");
+ assertEquals(nils, tweet.getOwner(), "Konstruktøren initialiserte tweeten med feil eier");
+ }
+
+ @Test
+ @DisplayName("Sjekk at retweet har samme tekst, men forskjellig eier")
+ void constructorRetweet() {
+ retweet1 = new Tweet(ole, tweet);
+ assertEquals("Kvitre!", retweet1.getText());
+ assertEquals(ole, retweet1.getOwner());
+ assertThrows(RuntimeException.class, () -> {
+ new Tweet(nils, tweet);
+ }, "En person skal ikke kunne retweete seg selv");
+ }
+
+ @Test
+ @DisplayName("Sjekk at originaltweet alltid er riktig")
+ void getOriginalTweet() {
+ assertNull(tweet.getOriginalTweet());
+ retweet1 = new Tweet(ole, tweet);
+ assertEquals(tweet, retweet1.getOriginalTweet());
+ assertEquals(retweet1.getOriginalTweet().getText(), retweet1.getText());
+ retweet2 = new Tweet(kari, tweet);
+ assertEquals(tweet, retweet1.getOriginalTweet());
+ assertEquals(retweet1.getOriginalTweet().getText(), retweet1.getText());
+ }
+
+ @Test
+ @DisplayName("Sjekk at retweetcount øker når en tweet retweetes")
+ void getRetweetCount() {
+ assertEquals(0, tweet.getRetweetCount());
+ new Tweet(ole, tweet);
+ assertEquals(1, tweet.getRetweetCount());
+ new Tweet(kari, tweet);
+ assertEquals(2, tweet.getRetweetCount());
+ }
+}
diff --git a/ovinger/src/test/java/oving4/TwitterAccountTest.java b/ovinger/src/test/java/oving4/TwitterAccountTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3833367e6540c4753add5471d6e051269f5fafa
--- /dev/null
+++ b/ovinger/src/test/java/oving4/TwitterAccountTest.java
@@ -0,0 +1,132 @@
+package oving4;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class TwitterAccountTest {
+ TwitterAccount nils;
+ TwitterAccount ole;
+
+ @BeforeEach
+ public void setup() {
+ nils = new TwitterAccount("Nils");
+ ole = new TwitterAccount("Ole");
+ }
+
+ private void checkFollow(TwitterAccount accountA, TwitterAccount accountB, boolean AfollowsB, boolean BfollowsA) {
+ if (AfollowsB) {
+ assertTrue(accountA.isFollowing(accountB),
+ String.format("%s skulle fulgt %s", accountA.getUserName(), accountB.getUserName()));
+ assertTrue(accountB.isFollowedBy(accountA),
+ String.format("%s skulle vært fulgt av %s", accountB.getUserName(), accountA.getUserName()));
+ } else {
+ assertFalse(accountA.isFollowing(accountB),
+ String.format("%s skulle ikke fulgt %s", accountA.getUserName(), accountB.getUserName()));
+ assertFalse(accountB.isFollowedBy(accountA),
+ String.format("%s skulle ikke vært fulgt av %s", accountB.getUserName(), accountA.getUserName()));
+ }
+ if (BfollowsA) {
+ assertTrue(accountB.isFollowing(accountA),
+ String.format("%s skulle fulgt %s", accountB.getUserName(), accountA.getUserName()));
+ assertTrue(accountA.isFollowedBy(accountB),
+ String.format("%s skulle vært fulgt av %s", accountA.getUserName(), accountB.getUserName()));
+ } else {
+ assertFalse(accountB.isFollowing(accountA),
+ String.format("%s skulle ikke fulgt %s", accountB.getUserName(), accountA.getUserName()));
+ assertFalse(accountA.isFollowedBy(accountB),
+ String.format("%s skulle ikke vært fulgt av %s", accountA.getUserName(), accountB.getUserName()));
+ }
+ }
+
+ @Test
+ @DisplayName("Sjekk at konstruktør setter opp kontoen riktig")
+ void testConstructor() {
+ assertEquals("Nils", nils.getUserName());
+ assertEquals(0, nils.getTweetCount());
+ assertEquals("Ole", ole.getUserName());
+ assertEquals(0, ole.getTweetCount());
+ }
+
+ @Test
+ @DisplayName("Test that follow is implemented correctly")
+ void testFollow() {
+ nils.follow(ole);
+ checkFollow(nils, ole, true, false);
+
+ ole.follow(nils);
+ checkFollow(nils, ole, true, true);
+ }
+
+ @Test
+ void testUnfollow() {
+ checkFollow(nils, ole, false, false);
+
+ nils.follow(ole);
+ checkFollow(nils, ole, true, false);
+
+ nils.unfollow(ole);
+ checkFollow(nils, ole, false, false);
+ }
+
+ @Test
+ void testNewTweet() {
+ nils.tweet("Kvitre!");
+ assertEquals(1, nils.getTweetCount(), "Tweetcounten til Nils skulle vært 1");
+ assertEquals("Kvitre!", nils.getTweet(1).getText(), "Teksten skulle vært Kvitre");
+ nils.tweet("Kvitre igjen!");
+ assertEquals(2, nils.getTweetCount());
+ assertEquals("Kvitre igjen!", nils.getTweet(1).getText());
+ assertEquals("Kvitre!", nils.getTweet(2).getText());
+ }
+
+ @Test
+ void testIllegalTweet() {
+ assertThrows(RuntimeException.class, () -> {
+ nils.getTweet(1);
+ }, "Skal ikke kunne hente en tweet som ikke fins");
+ assertThrows(RuntimeException.class, () -> {
+ nils.getTweet(-1);
+ }, "Skal ikke kunne hente en tweet som ikke fins");
+ nils.tweet("Kvitre!");
+ assertThrows(RuntimeException.class, () -> {
+ nils.getTweet(2);
+ }, "Skal ikke kunne hente en tweet som ikke fins");
+ assertThrows(RuntimeException.class, () -> {
+ nils.getTweet(-1);
+ }, "Skal ikke kunne hente en tweet som ikke fins");
+ }
+
+ @Test
+ @DisplayName("Sjekk at retweet funker, også med retweet av retweet")
+ void testRetweet() {
+ TwitterAccount kari = new TwitterAccount("Kari");
+
+ nils.tweet("Kvitre!");
+ assertEquals(1, nils.getTweetCount());
+ assertEquals("Kvitre!", nils.getTweet(1).getText());
+
+ ole.retweet(nils.getTweet(1));
+ assertEquals(1, nils.getTweetCount());
+ assertEquals(1, nils.getRetweetCount());
+ assertEquals(1, ole.getTweetCount());
+ assertEquals(0, ole.getRetweetCount());
+ assertEquals("Kvitre!", ole.getTweet(1).getText());
+ assertEquals(nils.getTweet(1), ole.getTweet(1).getOriginalTweet());
+
+ kari.retweet(ole.getTweet(1));
+ assertEquals(1, nils.getTweetCount());
+ assertEquals(2, nils.getRetweetCount());
+ assertEquals(1, ole.getTweetCount());
+ assertEquals(0, ole.getRetweetCount());
+ assertEquals(1, kari.getTweetCount());
+ assertEquals(0, kari.getRetweetCount());
+ assertEquals("Kvitre!", kari.getTweet(1).getText());
+ assertEquals(nils.getTweet(1), kari.getTweet(1).getOriginalTweet());
+ }
+}
diff --git a/ovinger/src/test/java/oving4/testing/CoffeeCupTest.java b/ovinger/src/test/java/oving4/testing/CoffeeCupTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f5daf239c945517b442afe6c91124ea815d1adf
--- /dev/null
+++ b/ovinger/src/test/java/oving4/testing/CoffeeCupTest.java
@@ -0,0 +1,5 @@
+package oving4.testing;
+
+public class CoffeeCupTest {
+
+}