Emerald testing problem

const SC <- class myClass
    var prev: Integer <- 0
    export operation getSeqNo[] -> [r: Integer]
        prev <- prev +1
        r <- prev
    end getSeqno
end myClass


const hello <- object hello
    operation test[y : Integer]
        var x : Integer <- 6
        x <- x+y
        stdout.putstring[" test " || x.asString || "\n"]
        stdout.flush
    end test

    initially
        Var myClassInstance : SC
        var n: Node
        myClassInstance <- SC.create[]
        move myClassInstance to n
        for i : Integer <- 0 while i < 10 by i <- i + 1
            stdout.putstring[" test " || (myClassInstance.getSeqNo).asString || "\n"]
        end for
        self.test[5]
    end initially
end hello


%Task 1
const conformingType <- class ConformingType
    var arr : Array.of[String] <- Array.of[String].create[1]

    operation add[name : String] -> [res : Boolean]
        arr.addUpper[name]
        res <- true
    end add
    function contains[name : String] -> [res : Boolean]
        res <- false
        for i : Integer <- 0 while i < 10 by i <- i + 1
            if arr[i] == name then
                res <- true
            end if
        end for
    end contains
    operation remove[navn : String ] -> [res : Boolean]
        %No remove op as far as I know
    end remove
end ConformingType

%Task 2
const Sieveof <- class Eratosthanes
    var numbers: Array.of[Boolean] <-Array.of[Boolean].create[200]
    var p : Integer

    export operation makeSieve[]
        p <- 2
        loop
            if p > 198 then exit end if
            for i : Integer <- 0 while i < 200 by  i <- i + p
                numbers[i-1] <- false
            end for

            for i : Integer <- 0 while i < 200 by  i <- i + 1
                if numbers[i]
                then p <- i + 1
                exit
                end if
            end for
        end loop
    end makeSieve
end Eratosthanes

%mandatory assignment 1
%Barrier
const data <- class Data
    var ID: Integer <- -1
    var waiting : Boolean <- false
end data


const thread <- class Thread[barr : Barrier, ID : Integer]
    operation repportCompletion[]
        barr.repportAsReady[ID]
    end repportCompletion
end thread

const barrier <- class Barrier
    var numConnected : Integer <- 0
    var threads : Array.of[Data] <- Array.of[Data].create[4] % 4 is the standard num of min threads, enough for most cases
    export operation addThread[ID : Integer]
        threads[ID].ID <- ID
        threads[ID].waiting <- true
        numConnected <- numConnected + 1
    end addThread

    export operation isReady[] -> [ready: Boolean]
        ready <- numConnected == 0
    end isReady

    export operation repportAsReady[ID : Integer]
        threads[ID].waiting <- false
        numConnected <- numConnected - 1
    end repportAsReady
end barrier


%Producer/Consumer

%We need a singleton buffer object
const wrapperObject <- class Wrapper


    const producer <- class Producer
        var sentValueNum : Integer <- 1
        initially
            loop
                exit when sentValueNum > 29
                var sucess : Boolean <- bufferObject.add[sentValueNum]
                %Print what you sent
                if sucess then sentValueNum <- sentValueNum + 1 end if
            end loop
        end initially
    end Producer

    const consumer <- class Consumer
        var recievedValueNum : Integer <- 0
        initially
            loop exit when recievedValueNum > 29
                var recievedVal: Integer <- bufferObject.get[]
                %Print what you got
                if recievedVal !== 0 then recievedValueNum <- recievedValueNum + 1 end if
            end loop
        end initially
    end Consumer

    const bufferObject <- class Buffer
        var bufferArray : Array.of[Integer] <- Array.of[Integer].create[2]

        export operation remove[] -> [r: Integer]
            r <- 0
            for i : Integer <- 0 while i < 2 by  i <- i + 1
                if bufferArray[i] !== 0 then
                    r <- bufferArray[i]
                    bufferArray[i] <- 0
                    exit
                end if
            end for
        end remove

        export operation add[val : Integer] -> [success: Boolean]
            success <- false
            for i : Integer <- 0 while i < 2 by  i <- i + 1
                if bufferArray[i] == 0 then
                    bufferArray[i] <- val
                    success <- true
                    exit
                end if
            end for
        end add
    end Buffer
end Wrapper