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.4.18+commit.9cf6e910.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;
    }
}

kycContract.sol

pragma solidity ^0.4.24;

contract kyc1
{
    
    uint256 public set;
 
 
   function setSetter(uint256 a)
        public
        {
            set = a;
            
        }
    
    
    
}


contract kyc2
{
    
    kyc1 k1;
    uint256 public set;
 
 
   function setK1(address k,uint256 b)
        public
        {
              k1  = kyc1(k);
              k1.setSetter(b);    
        }
    
    
    
}

Voting.sol

pragma solidity ^0.4.18; 

contract Voting 
{
    
       event AddedCandidate(uint candidateID);
        address owner;
        
          function Voting()
          public 
          { 
              owner=msg.sender;
           }
          
          
          modifier onlyOwner 
          {       
              require(msg.sender == owner);       _;    
              
          }   
          
          struct Voter
          {         uint candidateIDVote;   
                    bool hasVoted;  
                     bool isAuthorized;
          } 
          
           struct Candidate 
           { 
               string name;       
               string party;     
               uint noOFVotes;   
               bool doesExist;       
            }
            
             uint numCandidates; // declares a state variable - number Of Candidates  
             uint numVoters;  
             uint numOfVotes ;
             
             
              mapping (uint => Candidate) candidates;  
              mapping (address => Voter) voters;
              
              
              function addCandidate(string name, string party) onlyOwner
              public {    
                    // candidateID is the return variable     
                    uint candidateID = numCandidates++;     
                    // Create new Candidate Struct with name and saves it to storage. 
                    candidates[candidateID] = Candidate(name,party,0,true);
                    AddedCandidate(candidateID);
                    }
                    
                    
                      function vote(uint candidateID)
                      public
                      {         // checks if the struct exists for that candidate
                                require(!voters[msg.sender].hasVoted);
                                require(voters[msg.sender].isAuthorized);
                                // this statement is to check this voter is not already voted  
                                if (candidates[candidateID].doesExist == true)
                                {           
                                    voters[msg.sender] = Voter(candidateID, true, true); 
                                    candidates[candidateID].noOFVotes++;
                                    numOfVotes++;          
                                    numVoters++;       
                                }    
                      }
                      
                      
                      
                      
                      function totalVotes(uint candidateID) view public returns (uint)
                      {             
                          return candidates[candidateID].noOFVotes;  
                      }
                      
                      
                       function getNumOfCandidates() public view returns(uint)
                       {     
                           return numCandidates;  
                       }
                       
                       
                       function getNumOfVoters() public view returns(uint)
                       {
                           return numVoters; 
                       } 
                       
                       // returns candidate information, including its ID, name, and party
                       
                       function getCandidate(uint candidateID) 
                       public view returns (uint,string,string,uint) 
                       {
                           return (candidateID,candidates[candidateID].name,candidates[candidateID].party,candidates[candidateID].noOFVotes); 
                        } 
                        
                        
                         function Authorize(address _Voter) onlyOwner public 
                            {
                                    voters[_Voter].isAuthorized = true;
                            }
                            
                                        
                    function checkAuthorize(address _Voter) public view returns(bool)
                       {
                            return voters[_Voter].isAuthorized; 
                       } 
                
                       
}