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.11+commit.c082d0b4.js&optimize=false&gist=

ballot.sol

pragma solidity >=0.4.22 <0.6.0;
contract Ballot {

    struct Voter {
        uint weight;
        bool voted;
        uint8 vote;
        address delegate;
    }
    struct Proposal {
        uint voteCount;
    }

    address chairperson;
    mapping(address => Voter) voters;
    Proposal[] proposals;

    /// Create a new ballot with $(_numProposals) different proposals.
    constructor(uint8 _numProposals) public {
        chairperson = msg.sender;
        voters[chairperson].weight = 1;
        proposals.length = _numProposals;
    }

    /// Give $(toVoter) the right to vote on this ballot.
    /// May only be called by $(chairperson).
    function giveRightToVote(address toVoter) public {
        if (msg.sender != chairperson || voters[toVoter].voted) return;
        voters[toVoter].weight = 1;
    }

    /// Delegate your vote to the voter $(to).
    function delegate(address to) public {
        Voter storage sender = voters[msg.sender]; // assigns reference
        if (sender.voted) return;
        while (voters[to].delegate != address(0) && voters[to].delegate != msg.sender)
            to = voters[to].delegate;
        if (to == msg.sender) return;
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegateTo = voters[to];
        if (delegateTo.voted)
            proposals[delegateTo.vote].voteCount += sender.weight;
        else
            delegateTo.weight += sender.weight;
    }

    /// Give a single vote to proposal $(toProposal).
    function vote(uint8 toProposal) public {
        Voter storage sender = voters[msg.sender];
        if (sender.voted || toProposal >= proposals.length) return;
        sender.voted = true;
        sender.vote = toProposal;
        proposals[toProposal].voteCount += sender.weight;
    }

    function winningProposal() public view returns (uint8 _winningProposal) {
        uint256 winningVoteCount = 0;
        for (uint8 prop = 0; prop < proposals.length; prop++)
            if (proposals[prop].voteCount > winningVoteCount) {
                winningVoteCount = proposals[prop].voteCount;
                _winningProposal = prop;
            }
    }
}

ballot_test.sol

pragma solidity >=0.4.22 <0.6.0;
import "remix_tests.sol"; // this import is automatically injected by Remix.
import "./ballot.sol";

contract test3 {
   
    Ballot ballotToTest;
    function beforeAll () public {
       ballotToTest = new Ballot(2);
    }
    
    function checkWinningProposal () public {
        ballotToTest.vote(1);
        Assert.equal(ballotToTest.winningProposal(), uint(1), "1 should be the winning proposal");
    }
    
    function checkWinninProposalWithReturnValue () public view returns (bool) {
        return ballotToTest.winningProposal() == 1;
    }
}

Inheritance.sol

pragma solidity ^0.5.0;

// Will show inheritance between two contracts

contract Minter{
    string name public;
    mapping(address => uint256) balances public;
    
    function mint() public{
        balances++;
    }
}

contract Transactor{
    // create object, use the object to call mint.
    // transfer the values in minter wallet to receiver wallet
    
    address minter_wallet public;
    address transactor_wallet public payable;
    
    constructor(address _minter, address _transactor) public{
        minter_wallet = _minter;
        transactor_wallet = _transactor;
    }
    
    
}

ListVoters.sol

pragma solidity ^0.5.0;

contract ListVoters {

    // register voters and display them on the webpage

    uint public voterNumber = 0;

    struct Voter{
        uint id;
        uint256 age;
        string name;
        bool voted;
    }

    constructor() public{
        addVoter(21, "Timothy Kimani", false);
    }

    mapping(uint256 => Voter) public voters;

    event VoterCreated(
        uint id,
        string name
    );

    function addVoter(uint256 _age, string memory _name, bool _voted) public {
        voterNumber ++;
        voters[voterNumber] = Voter(voterNumber, _age, _name,  _voted);
        emit VoterCreated(voterNumber, _name);
    }
}

Test.sol

pragma solidity ^0.5.0;

contract Test {
    string public name;
    
    struct People{
        string name;
        uint256 age;
    }
}

Voters_Test.sol

// File: contracts/Voting.sol

pragma solidity ^0.5.1;


contract Voting{
    mapping(bytes32 => uint256) public votesReceived;

    bytes32[] public candidateList;


    // We use an array of bytes32 because solidity doesnt allow passing of
    // strings arrays inside a constructor

    // We will convert this array to string values during deployment
    constructor(bytes32[] memory candidateNames) public {
        candidateList = candidateNames;
    }

    function totalVotesFor(bytes32 candidate) view public returns (uint256) {
        require(validCandidate(candidate));
        return votesReceived[candidate];
    }

    function voteForCandidate(bytes32 candidate) public {
        require(validCandidate(candidate));
        votesReceived[candidate] += 1;
    }

    function validCandidate(bytes32 candidate) view public returns (bool) {
        for(uint i = 0; i < candidateList.length; i++){
            if (candidateList[i] == candidate) {
                return true;
            }
        }
        return false;
    }
}