Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.5.17+commit.d19bba13.js&optimize=false&gist=

1_Storage.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Storage
 * @dev Store & retreive value in a variable
 */
contract Storage {

    uint256 number;

    /**
     * @dev Store value in variable
     * @param num value to store
     */
    function store(uint256 num) public {
        number = num;
    }

    /**
     * @dev Return value 
     * @return value of 'number'
     */
    function retreive() public view returns (uint256){
        return number;
    }
}

2_Owner.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor() public {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() external view returns (address) {
        return owner;
    }
}

3_Ballot.sol

pragma solidity >=0.4.22 <0.7.0;

/** 
 * @title Ballot
 * @dev Implements voting process along with vote delegation
 */
contract Ballot {
   
    struct Voter {
        uint weight; // weight is accumulated by delegation
        bool voted;  // if true, that person already voted
        address delegate; // person delegated to
        uint vote;   // index of the voted proposal
    }

    struct Proposal {
        // If you can limit the length to a certain number of bytes, 
        // always use one of bytes1 to bytes32 because they are much cheaper
        bytes32 name;   // short name (up to 32 bytes)
        uint voteCount; // number of accumulated votes
    }

    address public chairperson;

    mapping(address => Voter) public voters;

    Proposal[] public proposals;

    /** 
     * @dev Create a new ballot to choose one of 'proposalNames'.
     * @param proposalNames names of proposals
     */
    constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;

        for (uint i = 0; i < proposalNames.length; i++) {
            // 'Proposal({...})' creates a temporary
            // Proposal object and 'proposals.push(...)'
            // appends it to the end of 'proposals'.
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }
    
    /** 
     * @dev Give 'voter' the right to vote on this ballot. May only be called by 'chairperson'.
     * @param voter address of voter
     */
    function giveRightToVote(address voter) public {
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        require(voters[voter].weight == 0);
        voters[voter].weight = 1;
    }

    /**
     * @dev Delegate your vote to the voter 'to'.
     * @param to address to which vote is delegated
     */
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender];
        require(!sender.voted, "You already voted.");
        require(to != msg.sender, "Self-delegation is disallowed.");

        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // We found a loop in the delegation, not allowed.
            require(to != msg.sender, "Found loop in delegation.");
        }
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // If the delegate already voted,
            // directly add to the number of votes
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // If the delegate did not vote yet,
            // add to her weight.
            delegate_.weight += sender.weight;
        }
    }

    /**
     * @dev Give your vote (including votes delegated to you) to proposal 'proposals[proposal].name'.
     * @param proposal index of proposal in the proposals array
     */
    function vote(uint proposal) public {
        Voter storage sender = voters[msg.sender];
        require(sender.weight != 0, "Has no right to vote");
        require(!sender.voted, "Already voted.");
        sender.voted = true;
        sender.vote = proposal;

        // If 'proposal' is out of the range of the array,
        // this will throw automatically and revert all
        // changes.
        proposals[proposal].voteCount += sender.weight;
    }

    /** 
     * @dev Computes the winning proposal taking all previous votes into account.
     * @return winningProposal_ index of winning proposal in the proposals array
     */
    function winningProposal() public view
            returns (uint winningProposal_)
    {
        uint winningVoteCount = 0;
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                winningProposal_ = p;
            }
        }
    }

    /** 
     * @dev Calls winningProposal() function to get the index of the winner contained in the proposals array and then
     * @return winnerName_ the name of the winner
     */
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

4_Ballot_test.sol

pragma solidity >=0.4.22 <0.7.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./3_Ballot.sol";

contract BallotTest {
   
    bytes32[] proposalNames;
   
    Ballot ballotToTest;
    function beforeAll () public {
        proposalNames.push(bytes32("candidate1"));
        ballotToTest = new Ballot(proposalNames);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(0);
        Assert.equal(ballotToTest.winningProposal(), uint(0), "proposal at index 0 should be the winning proposal");
        Assert.equal(ballotToTest.winnerName(), bytes32("candidate1"), "candidate1 should be the winner name");
    }
    
    function checkWinninProposalWithReturnValue () public view returns (bool) {
        return ballotToTest.winningProposal() == 0;
    }
}

_Sample.sol

pragma solidity ^0.5.1;

contract testContract {

    uint value;

    constructor (uint _p) public {
        value = _p;
    }

    function setP(uint _n) payable public {
        value = _n;
    }

    function setNP(uint _n) public {
        value = _n;
    }

    function get () view public returns (uint) {
        return value;
    }
}

ballot.sol

pragma solidity >=0.5.1;
//which compiler

contract Inbox{
    string public message;
    
    constructor(string memory initialMessage) public{
        //function Inbox(string initialMessage)public{
        message = initialMessage;
    }
    
    function setMessage(string memory newMessage) public{
        message = newMessage;
    }
    
    function getMessage() public view returns (string memory){
        return message;
    }
}

DAO-IAM.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title DAO-IAM
 */
contract DAO-IAM {
    
    /**
     * @dev DAO_Registrar(DAO-IAM)
     * @input PII
     * @return encryptPII
     */
    function DAO_Registrar(PII) public returns (encryptPII){
        //encrypts the PII
        return encryptPII;
    }
    
     /**
     * @dev 5.Reg
     * @input agentId, ID, class, *hash, $
     * @return 
     */
    function RegRootID(agentId, ID, class, *hash, $) public returns (){
        //reg step
        success = true;
        
        //call (storage)*hash? validates the encrypted PII by hash*
        if(!Storage.Exist*hash(*hash))
        {
            success = false;
        }
        
        if(success)
        {
            //pass: performs a transaction
            Transaction(ID, *hash, agentId);
            reurn Ok();
        }
        else
        {
            return Error();
        }
    }
    
    /**
     * @dev 5.Reg DAO Registrar2(DAO-IAM)
     * @input ID, class, RootID, $
     * @return 
     */
    function Reg(ID, class, RootID, $) public {
        //reg step
        if(success)
        {
            //7.
            reurn Ok();
        }
    }
    
    /**
     * @dev DAO_DeRegistrar(DAO-IAM)
     * @input ID, class, $
     * @return
     */
    function DAO_DeRegistrar(ID, class, $) public returns (){
        
        Transaction(ID, *hash);
        if (class == rootClass)
        {
            DAO_DeRegistrar_Hold(ID, *hash);
        }
        
        return Ok();
    }
    
     /**
     * @dev DAO_DeRegistrar_Hold(DAO-IAM)
     * @input ID, *hash
     * @return
     */
    function DAO_DeRegistrar_Hold(ID, *hash) public returns (){
        
        PII_delete(ID, *hash);
        Storage.Delete(*hash);
        
        return Ok();
    }
    
     /**
     * @dev PII_delete
     * @input ID, *hash
     * @return
     */
    function PII_delete(ID, *hash) public {
    }
}

Debug.sol

pragma solidity >=0.5.1 <0.6.0;
contract Donation {
    address owner;
    event fundMoved(address _to, uint _amount);
    modifier onlyowner { if (msg.sender == owner) _; }
    address[] _giver;
    uint[] _values;

    constructor() public {
        owner = msg.sender;
    }

    function donate() payable  public {
        addGiver(msg.value);
    }

    function moveFund(address payable _to, uint _amount) onlyowner  public {
        uint balance = address(this).balance;
        uint amount = _amount;
        if (_amount <= balance) {
            if (_to.send(balance)) {
                emit fundMoved(_to, _amount);    
            } else {
               revert();
            }
        } else {
            revert();
        }
    }

    function addGiver(uint _amount) internal {
        _giver.push(msg.sender);
        _values.push(_amount);
    }
}

IdRegistration.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title IdRegistration
 */
contract IdRegistration {

    /**
     * @dev 1.Generate for non − class 1 ID registration
     * @input pubkey?, class
     * @return ID, class
     */
    function Generate(pubkey?, class) public view returns (ID, class){
        //generates key-pair
        //generate ID(uses the public key)
        //record ID, class, RootID
        return (ID, class);
    }
    
    /**
     * @dev 2.(Web)Reg
     * @input ID, class, RootID, PII
     * @return validation code
     */
    function Reg(ID, class, RootID, PII) public returns (validationCode){
        //reg step
        success = true;
        if(PII)
        {
            //validates the encrypted PII
            if(!isValid)
            {
                 success = false;
            }
        }
        
        if(success)
        {
            //Send Email-validation code
            Email(PII.email)
            reurn Ok(validationCode);
        }
        else
        {
            return Error();
        }
    }
    
    /**
     * @dev 3.Email
     * @input email
     * @return validation code
     */
    function Email(email) public returns (validationCode){
        //generate validation code
        //Send validation code
        return validationCode;
    }
    
    /**
     * @dev 4.RegConfirm
     * @input ID, class, RootID?, code
     * @return 
     */
    function RegConfirm(ID, class, RootID?, code) public {
        //8.
        return Ok();
    }
    
    /**
     * @dev 5.Reg DAO Registrar2(DAO-IAM)
     * @input ID, class, RootID, $
     * @return 
     */
    function Reg(ID, class, RootID, $) public {
        //reg step
        if(success)
        {
            //7.
            reurn Ok();
        }
    }
    
    /**
     * @dev 6.Transaction
     * @input ID, *hash
     * @return ID, class
     */
    function Transaction(ID, *hash) public {
        //record-this address registration on the blockchain
    }
}

Lab01_ballot.sol

pragma solidity >=0.5.1;
//which compiler

contract Inbox{
    string public message;
    
    constructor(string memory initialMessage) public{
        //function Inbox(string initialMessage)public{
        message = initialMessage;
    }
    
    function setMessage(string memory newMessage) public{
        message = newMessage;
    }
    
    function getMessage() public view returns (string memory){
        return message;
    }
}

scenario.json

{
  "accounts": {},
  "linkReferences": {},
  "transactions": [],
  "abis": {}
}

Storage.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title Storage
 */
contract Storage {
    
    /**
     * @dev Store
     * @input encryptPII, agentId, ID
     * @return *hash
     */
    function Store(encryptPII, agentId, ID) public returns (*hash){

        //Save the encrypted PII and return *hash
        *hash = Save(encryptPII, agentId, ID);
        reurn Ok(*hash);
    }
    
    /**
     * @dev Delete
     * @input *hash
     * @return 
     */
    function Delete(*hash) public returns (){

        //Delete the encrypted PII by *hash
        Delete(*hash);
        reurn Ok();
    }
}

test_test.sol

pragma solidity >=0.4.0 <0.7.0;
      import "remix_tests.sol"; // this import is automatically injected by Remix.

      // file name has to end with '_test.sol'
      contract test_1 {

        function beforeAll() public {
          // here should instantiate tested contract
          Assert.equal(uint(4), uint(3), "error in before all function");
        }

        function check1() public {
          // use 'Assert' to test the contract
          Assert.equal(uint(2), uint(1), "error message");
          Assert.equal(uint(2), uint(2), "error message");
        }

        function check2() public view returns (bool) {
          // use the return value (true or false) to test the contract
          return true;
        }
      }

    contract test_2 {

      function beforeAll() public {
        // here should instantiate tested contract
        Assert.equal(uint(4), uint(3), "error in before all function");
      }

      function check1() public {
        // use 'Assert' to test the contract
        Assert.equal(uint(2), uint(1), "error message");
        Assert.equal(uint(2), uint(2), "error message");
      }

      function check2() public view returns (bool) {
        // use the return value (true or false) to test the contract
        return true;
      }
    }

Untitled.sol

// this line is added to create a gist. Empty file is not allowed.

UserLocal.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title UserLocal
 */
contract UserLocal {

    /**
     * @dev 1.Generate for non − class 1 ID registration
     * @input pubkey?, class
     * @return ID, class
     */
    function Generate(pubkey?, class) public view returns (ID, class){
        //generates key-pair
        //generate ID(uses the public key)
        //record ID, class, RootID
        return (ID, class);
    }
}

WebSP.sol

pragma solidity >=0.4.22 <0.7.0;

/**
 * @title WebSP
 */
contract WebSP {
    
    /**
     * @dev 2.(Agent)Reg
     * @input ID, class, PII, $
     * @return *hash
     */
    function RegRootID(ID, class, PII, $) public returns (*hash){
        //reg step
        success = true;
        if(PII)
        {
            //validates the PII
            if(!isValid)
            {
                 success = false;
            }
        }
        
        if(success)
        {
            //call DAO Registrar(smart contract)-encrypts the PII
            encryptPII = DAO-IAM.DAO_Registrar(PII);
            //Send the encrypted PII to storage
            *hash = Storage.store(encryptPII, agentId, ID);
            reurn Ok(*hash);
        }
        else
        {
            return Error();
        }
    }

    /**
     * @dev 2.(Web)Reg
     * @input ID, class, RootID, PII
     * @return validation code
     */
    function Reg(ID, class, RootID, PII) public returns (validationCode){
        //reg step
        success = true;
        if(PII)
        {
            //validates the encrypted PII
            if(!isValid)
            {
                 success = false;
            }
        }
        
        if(success)
        {
            //Send Email-validation code
            Email(PII.email)
            reurn Ok(validationCode);
        }
        else
        {
            return Error();
        }
    }
    
    /**
     * @dev 3.Email
     * @input email
     * @return validation code
     */
    function Email(email) public returns (validationCode){
        //generate validation code
        //Send validation code
        return validationCode;
    }
    
    /**
     * @dev 4.RegConfirm
     * @input ID, class, RootID?, code
     * @return 
     */
    function RegConfirm(ID, class, RootID?, code) public {
        //8.
        return Ok();
    }
}