text:
<?php
//se a classe for chamada pela area restrita do lei de acesso
if (empty($varAreaRestrita))
{
	include_once("../inc/security.php");
}

include_once("../inc/funcoes.php");
include('../solicitacao/upload.php');

class Solicitacao {

	private $idsolicitacao;
	private $textosolicitacao;
	private $formaretorno;
        private $numeroprotocolo;
	private $situacao;
        private $idtiposolicitacao;
        private $instancia;
        private $idsolicitacaoorigem;
	private $idsolicitante;
	private $solicitante;
        private $datasolicitacao;
        private $datarecebimentosolicitacao;
        private $usuariorecebimento;
        private $dataprevisaoresposta;
        private $dataprorrogacao;
        private $usuarioprorrogacao;
        private $motivoprorrogacao;
        private $dataresposta;
        private $resposta;
        private $usuarioresposta;
        private $idsecretariaselecionada;
        private $idsecretariaresposta;
        private $erro;

        //campos de movimentação
        private $idsecretariadestino;
        private $despacho;
        //campos de finalização
        private $tiporesposta;

	//instancia
	public function getInstancia(){
		return $this->instancia;
	}

	//dataprevisaoresposta
	public function getDataPrevisaoResposta(){
		return $this->dataprevisaoresposta;
	}
	public function setDataPrevisaoResposta($valor){
		$this->dataprevisaoresposta = $valor;
	}

	//dataprorrogaca
	public function getDataProrrogacao(){
		return $this->dataprorrogacao;
	}
	public function setDataProrrogacao($valor){
		$this->dataprorrogacao = $valor;
	}

	//motivoprorrogacao
	public function getMotivoProrrogacao(){
		return $this->motivoprorrogacao;
	}
	public function setMotivoProrrogacao($valor){
		$this->motivoprorrogacao = str_replace("'","\'",$valor);
	}

	//idsolicitacaoorigem
	public function getUsuarioProrrogacao(){
		return $this->usuarioprorrogacao;
	}
	public function setUsuarioProrrogacao($valor){
		$this->usuarioprorrogacao = $valor;
	}

	//dataresposta
	public function getDataResposta(){
		return $this->dataresposta;
	}
	public function setDataResposta($valor){
		$this->dataresposta = $valor;
	}

	//resposta
	public function getResposta(){
		return $this->resposta;
	}
	public function setResposta($valor){
		$this->resposta = $valor;
	}

	//usuarioresposta
	public function getUsuarioResposta(){
		return $this->usuarioresposta;
	}
	public function setUsuarioResposta($valor){
		$this->usuarioresposta = $valor;
	}

	//idsecretariaresposta
	public function getIdSecretariaResposta(){
		return $this->idsecretariaresposta;
	}
	public function setIdSecretariaResposta($valor){
		$this->idsecretariaresposta = $valor;
	}

	//usuariorecebimento
	public function getUsuarioRecebimento(){
		return $this->usuariorecebimento;
	}
	public function setUsuarioRecebimento($valor){
		$this->usuariorecebimento = $valor;
	}

	//idsolicitacao
	public function getIdSolicitacao(){
		return $this->idsolicitacao;
	}

	public function setIdSolicitacao($valor){
		$this->idsolicitacao = $valor;
	}

        //datasolicitacao
	public function getDataSolicitacao(){
		return $this->datasolicitacao;
	}
	public function setDataSolicitacao($valor){
		$this->datasolicitacao = $valor;
	}

	//datarecebimentosolicitacao
	public function getDataRecebimentoSolicitacao(){
		return $this->datarecebimentosolicitacao;
	}
	public function setDataRecebimentoSolicitacao($valor){
		$this->datarecebimentosolicitacao = $valor;
	}

	//idsolicitacaoorigem
	public function getIdSolicitacaoOrigem(){
		return $this->idsolicitacaoorigem;
	}
	public function setIdSolicitacaoOrigem($valor){
		$this->idsolicitacaoorigem = $valor;
	}

	//idtiposolicitacao
	public function getIdTipoSolicitacao(){
		return $this->idtiposolicitacao;
	}
	public function setIdTipoSolicitacao($valor){
		$this->idtiposolicitacao = $valor;
	}
	//descrição tipo solicitação
	public static function getDescricaoTipoSolicitacao($idtiposolicitacao){

                $rs = execQuery("select nome from lda_tiposolicitacao where idtiposolicitacao = $idtiposolicitacao");

		if(mysqli_num_rows($rs)>0)
		{
                        $row = mysqli_fetch_array($rs);
                        return $row["nome"];
                }
                else
                    return "Tipo de solicitação não encontrado";

	}

	//textosolicitacao
	public function getTextoSolicitacao(){
		return $this->textosolicitacao;
	}
	public function setTextoSolicitacao($valor){
		$this->textosolicitacao = str_replace("'","\'",$valor);
	}

       	//numprotocolo
	public function getNumeroProtocolo(){
		return $this->numeroprotocolo;
	}
	public function setNumeroProtocolo($numero,$ano){
		$this->numeroprotocolo = $numero."/".$ano;
	}

        //secretaria selecionada (pelo usuario na hora de fazer a solicitação)
	public function getIdSecretariaSelecionada(){
		return $this->idsecretariaselecionada;
	}
	public function setIdSecretariaSelecionada($valor){
		$this->idsecretariaselecionada = $valor;
	}

        //formaretorno
	public function getFormaRetorno(){
		return $this->formaretorno;
	}
	public function setFormaRetorno($valor){
		$this->formaretorno = $valor;
	}

	//descrição tipo retorno
	public static function getDescricaoFormaRetorno($formaretorno){
		switch($formaretorno)
                {
                    case "E": return "E-mail"; break;
                    case "F": return "Fax"; break;
                    case "C": return "Correio"; break;
                    default: return "Forma de retorno inexistente";
                }
	}

	//descrição tipo de instancia
	public static function getDescricaoTipoInstancia($instancia){
		switch($instancia)
                {
                    case "I": return "Inicial"; break;
                    case "S": return "Seguimento"; break;
                    case "U": return "Última"; break;
                    default: return "Instancia inexistente";
                }
	}

	//situacao
	public function getSituacao(){
		return $this->situacao;
	}
	public function setSituacao($valor){
		$this->situacao = $valor;
	}
	//descrição situacao
	public static function getDescricaoSituacao($situacao){
		switch($situacao)
                {
                    case "A": return "Aberto"; break;
                    case "T": return "Em tramitacao"; break;
                    case "N": return "Negado"; break;
                    case "R": return "Solicitação Respondida"; break;
                    default: return "Situação inexistente";
                }
	}

	//idsolicitante
	public function getIdSolicitante(){
		return $this->idsolicitante;
	}
	public function setIdSolicitante($valor){
		$this->idsolicitante = $valor;
	}

	//erro
	public function getErro(){
		return $this->erro;
	}

	public function getSolicitante(){
		return $this->solicitante;
	}

	//--------CONSTRUTOR---------------------------

	function Solicitacao($idsolicitacao=null)
	{
		if(!empty($idsolicitacao))
		{
			$this->getDados($idsolicitacao);
		}
	}

	//---------------------------------------------

	function getDados($idsolicitacao)
	{
		$sql = "select t.*, c.nome as solicitante,
                        urec.nome as usuariorecebimento, upro.nome as usuarioprorrogacao,
                        ures.nome as usuarioresposta, ts.instancia
                        from lda_solicitacao t
                        join lda_solicitante c on c.idsolicitante = t.idsolicitante
                        join lda_tiposolicitacao ts on ts.idtiposolicitacao = t.idtiposolicitacao
                        left join sis_usuario urec on urec.idusuario = t.idusuariorecebimento
                        left join sis_usuario upro on upro.idusuario = t.idusuarioprorrogacao
                        left join sis_usuario ures on ures.idusuario = t.idusuarioresposta
                        where idsolicitacao = $idsolicitacao";

		$rs = execQuery($sql);

		if(mysqli_num_rows($rs)>0)
		{
			$row = mysqli_fetch_array($rs);

			$this->idsolicitacao		= $row["idsolicitacao"];
                        $this->idsolicitacaoorigem      = $row["idsolicitacaoorigem"];
			$this->textosolicitacao 	= $row["textosolicitacao"];
			$this->situacao			= $row["situacao"];
			$this->formaretorno		= $row["formaretorno"];
			$this->idsolicitante		= $row["idsolicitante"];
			$this->solicitante		= $row["solicitante"];
                        $this->idtiposolicitacao	= $row["idtiposolicitacao"];
                        $this->instancia                = $row["instancia"];
                        $this->setNumeroProtocolo($row["numprotocolo"],$row["anoprotocolo"]);
                        $this->datasolicitacao          = bdToDate($row["datasolicitacao"]);
                        $this->datarecebimentosolicitacao = bdToDate($row["datarecebimentosolicitacao"]);
                        $this->usuariorecebimento         = $row["usuariorecebimento"];
                        $this->dataprevisaoresposta       = bdToDate($row["dataprevisaoresposta"]);
                        $this->dataprorrogacao            = bdToDate($row["dataprorrogacao"]);
                        $this->motivoprorrogacao          = $row["motivoprorrogacao"];
                        $this->usuarioprorrogacao         = $row["usuarioprorrogacao"];
                        $this->dataresposta               = bdToDate($row["dataresposta"]);
                        $this->resposta                   = $row["resposta"];
                        $this->usuarioresposta            = $row["usuarioresposta"];
                        $this->idsecretariaselecionada    = $row["idsecretariaselecionada"];
                        $this->idsecretariaresposta       = $row["idsecretariaresposta"];

		}
		else
			die("Solicitação nao informada");
	}

	public static function getParametrosConfiguracao()
        {
                //recupera parametros de configuracao
                $sql = "select * from lda_configuracao";
                $rs = execQuery($sql);

                return mysqli_fetch_array($rs);

        }

        //recupera a instancia do tipo de solicitação passado: [I]inicial - [S]eguimento - [U]ltima
       	public static function getInstaciaTipoSolicitacao($idtiposolicitacao)
        {
                //recupera a instancia do tipo de solicitação
                $sql = "select instancia from lda_tiposolicitacao where idtiposolicitacao = $idtiposolicitacao";
                $rs = execQuery($sql);

                $row = mysqli_fetch_array($rs);

                return $row['instancia'];

        }

        //recupera o proximo tipo de solicitação para uma solicitação informada
       	public function getProximoTipoSolicitacao($idsolicitacao="",&$idtiposolicitacao, &$erro="")
        {
            $erro="";

            //se for passado uma solicitação
            if(!empty($idsolicitacao))
            {
                //recupera o proximo tipo de solicitacao
                $sql = "select idtiposolicitacao_seguinte from lda_tiposolicitacao
                        where idtiposolicitacao = (select idtiposolicitacao
                                                    from lda_solicitacao
                                                    where idsolicitacao = $idsolicitacao)";
                $rs = execQuery($sql);

                if (mysqli_num_rows($rs)>0)
                {
                    $row = mysqli_fetch_array($rs);
                    $idtiposolicitacao = $row['idtiposolicitacao_seguinte'];

                    //se não for encontrado novo tipo de solicitação
                    if(empty($idtiposolicitacao))
                    {
                        $erro = "Não é possível inserir novo recurso para essa solicitação, pois essa solicitação já está na última instância.";
                        return false;
                    }
                }
                else
                {
                    $erro = "Não foi encontrado tipo de solicitação para essa solicitação";
                    return false;
                }

            }
            else
            {
                //recupera a solicitação inicial
                $sql = "select idtiposolicitacao from lda_tiposolicitacao where instancia = 'I'";
                $rs = execQuery($sql);

                if (mysqli_num_rows($rs)>0)
                {
                    $row = mysqli_fetch_array($rs);
                    $idtiposolicitacao = $row['idtiposolicitacao'];
                }
                else
                {
                    $erro = "Não foi encontrado instância inicial cadastrada no sistema.";
                    return false;
                }
            }

            return true;
        }

	function validaDados($instancia="I")
	{

                if($instancia != "I")
		{
                        if (empty($this->idsolicitacaoorigem))
                        {
                            $this->erro = "Processo não informado.";
                            return false;
                        }

		}

		if (empty($this->textosolicitacao))
		{
			$this->erro = "Especificação da solicitação não informada.";
			return false;
		}
		elseif (empty($this->formaretorno))
		{
			$this->erro = "Forma de retorno não informado";
			return false;
		}
		elseif (empty($this->idsolicitante))
		{
			$this->erro = "Solicitante não informado";
			return false;
		}

                if ($this->formaretorno == "C" or $this->formaretorno == "F")
                {
                    $rs = execQuery("select logradouro, uf, cidade, telefone, dddtelefone from lda_solicitante where idsolicitante = $this->idsolicitante");
                    $row = mysqli_fetch_array($rs);

                    //se a forma de retorno for correio, verifica se existe endereço cadastrado
                    if($this->formaretorno == "C" and (empty($row['logradouro']) or empty($row['uf']) or empty($row['cidade'])))
                    {
                            $this->erro = "Para forma de retorno via correio é necessário atualizar o endereço no seu cadastro.";
                            return false;
                    }
                    //se a forma de retorno for telefone
                    elseif($this->formaretorno == "F" and (empty($row['telefone']) or empty($row['dddtelefone'])))
                    {
                            $this->erro = "Para forma de retorno via correio é necessário atualizar o telefone no seu cadastro.";
                            return false;
                    }
                }

		//verifica se ja existe registro cadastrado com a informaçao passada ---
		if (!empty($this->idsolicitacao))
			$sql = "select * from lda_solicitacao
					where textosolicitacao = '$this->textosolicitacao'
						  and formaretorno = '$this->formaretorno'
						  and idsolicitante = $this->idsolicitante
						  and idsolicitacao <> $this->idsolicitacao";
		else
			$sql = "select * from lda_solicitacao
					where textosolicitacao = '$this->textosolicitacao'
						  and formaretorno = '$this->formaretorno'
						  and idsolicitante = $this->idsolicitante ";

		if(mysqli_num_rows(execQuery($sql)) > 0)
		{
			$this->erro = "Essa solicitação já está cadastrada.";
			return false;
		}
		//-----------------------------------------------------------------------

		return true;
	}

        //envia email de aviso de nova solicitação para o SIC
        //secretaria -> recebe o idsecretaria ou sigla
        //tipomsg    -> identifica o tipo de mensagem: [M]ovimentação - [N]ova solicitação - [R]ecurso
        public static function enviaEmailSic($secretaria, $tipomsg="M")
        {
                //recupera o email do SIC
                $sql = "select emailsic
                        from sis_secretaria
                        where sigla = '$secretaria' or idsecretaria = '$secretaria'";

                $rs = execQuery($sql);

                if(mysqli_num_rows($rs)>0)
                {
                        $row = mysqli_fetch_array($rs);
                        $emailsic = $row["emailsic"];
                }

                //se houver email cadastrado, faz o envio
                if(!empty($emailsic))
                {
                    //se for movimentação
                    if($tipomsg == "M")
                    {
                        $titulo = "Movimentação de solicitação de informação";
                        $body="Prezado(a) colaborador(a),

                                Foi movimentada uma solicitação de informação para o seu órgão. Favor verificar a demanda no sistema ".SISTEMA_NOME." no endereço: ".URL_BASE_SISTEMA."

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }
                    //se for nova solicitação
                    else if($tipomsg == "N")
                    {
                        $titulo = "Nova solicitação de informação - ";
                        $body="Prezado(a) colaborador(a),

                                Foi aberta uma solicitação de informação. Favor verificar a demanda no sistema ".SISTEMA_NOME." no endereço: ".URL_BASE_SISTEMA."

                                Mensagem Automática do Sistema ".SISTEMA_NOME;

						/*$titulo = "Nova de solicitação de informação - ".$demanda->getNumeroProtocolo()."";
						$body	= "Prezado(a) colaborador(a),

							Foi aberta uma solicitação de informação com número de protocolo  ".$demanda->getNumeroProtocolo().", com a seguinte descrição:
"
							. '"' .$demanda->getTextoSolicitacao(). '"' . "

							Favor verificar a solicitação e dar encaminahmentos necessários através do ".URL_BASE_SISTEMA.".

							Mensagem Automática do Sistema ".SISTEMA_NOME.".";*/
                    }
                    //se for novo recurso
                    else if($tipomsg == "R")
                    {
                        $titulo = "Novo recurso de solicitação de informação";
                        $body="Prezado(a) colaborador(a),

                                Foi aberta uma solicitação de informação. Favor verificar a demanda no sistema ".SISTEMA_NOME." no endereço: ".URL_BASE_SISTEMA."

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }
                    else
                    {
                        $titulo = "Solicitação de informação";
                        $body="Prezado(a) colaborador(a),

                                Foi aberta uma solicitação de informação. Favor verificar a demanda no sistema ".SISTEMA_NOME." no endereço: ".URL_BASE_SISTEMA."

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }

                    if (!sendmail($emailsic,$titulo,$body))
                    {
                            //caso de erro loga o erro
                            logger("Lei de acesso - Não foi possível enviar e-mail para o SIC: $emailsic");
                    }
                }

        }

        //envia email de aviso para o solicitante
        //secretaria -> recebe o idsecretaria ou sigla
        //tipomsg    -> identifica o tipo de mensagem: [N]ova solicitação - [P]rorrogada - [R]esposta da solicitação
        public static function enviaEmailSolicitante($idsolicitacao, $tipomsg="N")
        {
                //recupera o email do solicitante
                $sql = "select pes.email, pes.nome, sol.dataprevisaoresposta, sol.numprotocolo, sol.anoprotocolo
                        from lda_solicitacao sol, lda_solicitante pes
                        where sol.idsolicitante = pes.idsolicitante
                              and sol.idsolicitacao = $idsolicitacao";

                $rs = execQuery($sql);

                if(mysqli_num_rows($rs)>0)
                {
                        $row = mysqli_fetch_array($rs);
                        $email = $row["email"];
                        $nome =  $row["nome"];
                        $processo = $row["numprotocolo"]."/".$row["anoprotocolo"];
                        $dataprevisaoresposta = bdToDate($row['dataprevisaoresposta']);

                }

                //se houver email cadastrado, faz o envio
                if(!empty($email))
                {
                    //se for nova solicitação
                    if($tipomsg == "N")
                    {
                        $titulo = "Solicitação cadastrada";
                        $body="Prezado(a) $nome,

                                Sua solicitação $processo foi cadastrada com sucesso.

                                Data prevista para resposta: $dataprevisaoresposta

Para acompanhar o andamento, acesse o sistema ".SISTEMA_NOME." no endereço: ".SITELNK.".

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }
                    //se for resposta
                    else if($tipomsg == "R")
                    {
                        $titulo = "Sua solicitação foi respondida";
                        $body="Prezado(a) $nome,

                                Sua solicitação $processo foi respondida. Para mais informações acesse o sistema ".SISTEMA_NOME." no endereço: ".SITELNK.".

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }
                    //se for prorrogada
                    else if($tipomsg == "P")
                    {
                        $titulo = "A resposta a sua solicitação foi prorrogada";
                        $body="Prezado(a) $nome,

                                O atendimento a sua solicitação $processo foi prorrogado, data de previsão de resposta: $dataprevisaoresposta.

								Para mais informações acesse o sistema ".SISTEMA_NOME.".

                                Mensagem Automática do Sistema ".SISTEMA_NOME;
                    }

                    if (!sendmail($email,$titulo,$body))
                    {
                            //caso de erro loga o erro
                            logger("Lei de acesso - Não foi possível enviar e-mail para o solicitante: $email");
                    }
                }

        }

	public function cadastra()
	{
		if($this->validaDados())
		{

                        $configuracao = $this->getParametrosConfiguracao();
                        $prazoresposta = $configuracao['prazoresposta'];

                        //recupera o proximo tipo de solicitação, caso retorne falso, deu erro
                        if(!$this->getProximoTipoSolicitacao("",$idtiposolicitacao,$this->erro))
                                return false;

			$sql="INSERT INTO lda_solicitacao (
						textosolicitacao,
						formaretorno,
						idsolicitante,
                                                datasolicitacao,
                                                dataprevisaoresposta,
                                                idtiposolicitacao,
                                                idsecretariaselecionada
				) VALUES (
						'$this->textosolicitacao',
						'$this->formaretorno',
						'$this->idsolicitante',
                                                NOW(),
                                                date_add(NOW(), interval $prazoresposta DAY ),
                                                $idtiposolicitacao,
                                                ".(!empty($this->idsecretariaselecionada)?$this->idsecretariaselecionada:"null")."
				)";

			$con = db_open();

			//verificacao de upload
			global $upload;
			$upload = verificadados();

			if ($upload == 1){
				return false;
			}
			//-----------------------

			if (!mysqli_query($con,$sql))
			{

				$this->erro = "Erro ao inserir solicitação".$sql;
				$sucesso = false;
			}
			else
			{
				$this->idsolicitacao = mysqli_insert_id();

                                //recupera o numero do protocolo
                                $sql = "select numprotocolo, anoprotocolo
                                        from lda_solicitacao t
                                        where idsolicitacao = $this->idsolicitacao";

                                $rs = execQuery($sql);

                                if(mysqli_num_rows($rs)>0)
                                {
                                    $row = mysqli_fetch_array($rs);
                                    $this->setNumeroProtocolo($row["numprotocolo"],$row["anoprotocolo"]);
                                }

                                //se tiver sido selecionado um SIC
                                if(!empty($this->idsecretariaselecionada))
                                {
                                    //envia email de aviso de nova solicitação ao SIC centralizador
                                    Solicitacao::enviaEmailSic($rec['idsecretaria'],"N");
                                }
                                else
                                {
                                    //envia email para os SIC's centralizadores
                                    $sql = "select idsecretaria
                                            from sis_secretaria
                                            where siccentral = 1";

                                    $rs = execQuery($sql);

                                    if(mysqli_num_rows($rs)>0)
                                    {
                                        while($rec = mysqli_fetch_array($rs))
                                        {
                                            //envia email de aviso de nova solicitação ao SIC centralizador
                                            Solicitacao::enviaEmailSic($rec['idsecretaria'],"N");

                                        }
                                    }
                                }

                                //envia email de aviso de cadastro de solicitação ao solicitante
                                Solicitacao::enviaEmailSolicitante($this->idsolicitacao,"N");

				$this->erro = "";
				$sucesso = true;

			}
			//db_close($con);

			return $sucesso;
		}
		else
			return false;
	}

	public function cadastraRecurso($idtiposolicitacao)
	{
		if($this->validaDados($tiposolicitacao))
		{
                        $configuracao = Solicitacao::getParametrosConfiguracao();
                        $prazoresposta = $configuracao['prazorespostarecurso'];

			$sql="INSERT INTO lda_solicitacao (
						textosolicitacao,
						formaretorno,
						idsolicitante,
                                                datasolicitacao,
                                                dataprevisaoresposta,
                                                idtiposolicitacao,
                                                idsolicitacaoorigem,
                                                idsecretariaselecionada
				) VALUES (
						'$this->textosolicitacao',
						'$this->formaretorno',
						'$this->idsolicitante',
                                                NOW(),
                                                date_add(NOW(), interval $prazoresposta DAY ),
                                                '$idtiposolicitacao',
                                                $this->idsolicitacaoorigem,
                                                ".(!empty($this->idsecretariaselecionada)?$this->idsecretariaselecionada:"null")."
				)";

			$con = db_open();

			if (!mysqli_query($con,$sql))
			{

				$this->erro = "Erro ao inserir solicitação".$sql;
				$sucesso = false;
			}
			else
			{

				$this->erro = "";
				$sucesso = true;

                                //se tiver sido selecionado um SIC
                                if(!empty($this->idsecretariaselecionada))
                                {
                                    //envia email de aviso de nova solicitação ao SIC centralizador
                                    Solicitacao::enviaEmailSic($rec['idsecretaria'],"N");
                                }
                                else
                                {
                                    //envia email para os SIC's centralizadores
                                    $sql = "select idsecretaria
                                            from sis_secretaria
                                            where siccentral = 1";

                                    $rs = execQuery($sql);

                                    if(mysqli_num_rows($rs)>0)
                                    {
                                        while($rec = mysqli_fetch_array($rs))
                                        {
                                            //envia email de aviso de nova solicitação ao SIC centralizador
                                            Solicitacao::enviaEmailSic($rec['idsecretaria'],"N");

                                        }
                                    }
                                }

                                //envia email de aviso de cadastro de solicitação ao solicitante
                                Solicitacao::enviaEmailSolicitante($this->idsolicitacaoorigem,"N");

			}
			//db_close($con);

			return $sucesso;
		}
		else
			return false;
	}

        static public function movimenta($idsolicitacao, $secretariadestino, $despacho, $arquivo)
        {
                if(empty($secretariadestino))
                {
                    return "O campo secretaria de destino deve ser preenchido";
                }
                if(empty($despacho))
                {
                    return "O campo despacho deve ser preenchido";
                }

                //verifica se existe alguma movimentacao
                $sql="select count(*) as tot from lda_movimentacao where idsolicitacao = $idsolicitacao";

                $row = mysqli_fetch_array(execQuery($sql));
                //se existir movimenta??o
                if($row["tot"] > 0)
                {
                    //nao permite movimentar se a ultima movimentação não tiver sido dado o recebimento
                    $sql="select count(*) from lda_movimentacao
                        where idmovimentacao = (select max(idmovimentacao) from lda_movimentacao where idsolicitacao = $idsolicitacao)
                              and datarecebimento is null";

                    $row = mysqli_fetch_array(execQuery($sql));

                    //se ultima movimentação nao tiver sido recebida
                    if($row["tot"] > 0)
                        return "Não é possível movimentar solicitação que ainda não foi recebida!";

                }

                //recupera o status da demanda
                $sql="select situacao from lda_solicitacao where idsolicitacao = $idsolicitacao";
                $row = mysqli_fetch_array(execQuery($sql));
                $status = $row["situacao"];

                $con = db_open_trans();
                $all_query_ok=true;

		$sql="INSERT INTO lda_movimentacao
                        (
                         idsolicitacao,
                         idsecretariaorigem,
                         idsecretariadestino,
                         dataenvio,
                         idusuarioenvio,
                         despacho
                        ) VALUES (
                         $idsolicitacao,
                         ".getSession("idsecretaria").",
                         $secretariadestino,
                         NOW(),
                         ".getSession("uid").",
                         '".str_replace("'","\'",$despacho)."'
                        )
                    ";

		if (!$con->query($sql))
                {
                    $con->rollback();
                    return "Erro na movimentação da solicitação.";
                }
                else
                {
                    //se houver arquivo faz upload
                    if(!empty($arquivo["tmp_name"]))
                    {
                        $idmovimentacao = $con->insert_id;
                        $dir = getDiretorio("lda")."/";
                        $ext = getExtensaoArquivo($arquivo['name']);

                        $fullArquivo = "lda_".$idsolicitacao."_mov_".$idmovimentacao.".".$ext;

                        if (!@move_uploaded_file($arquivo["tmp_name"], $dir.$fullArquivo))
                        {
                                $erro = "Ocorreu um erro ao efetuar o upload do arquivo ".$dir.$fullArquivo."; nome:".$arquivo["tmp_name"];
                                $all_query_ok=false;
                                break;
                        }
                        else
                        {
                                $sql = "update lda_movimentacao set arquivo = '$fullArquivo' where idmovimentacao = $idmovimentacao";
                                if (!$con->query($sql))
                                {
                                        $erro = "Ocorreu um erro ao efetuar atualizar nome do arquivo";
                                        $all_query_ok=false;
                                        break;
                                }
                        }
                    }

                    //se o status da demanda for "aberto" altera para "em tramitação"
                    if($status == "A")
                    {
                        $sql = "update lda_solicitacao set situacao = 'T' where idsolicitacao=$idsolicitacao";
                        if (!$con->query($sql))
                        {
                            $con->rollback();
                            return "Ocorreu um erro ao atualizar a situação da solicitação";
                        }
                    }
                    $con->commit();

                    //envia email de aviso de nova solicitação ao SIC de destino
                    Solicitacao::enviaEmailSic($secretariadestino,"M");

                }
                return "";
        }

        static public function recebe($idsolicitacao)
        {
                $sql = "select situacao from lda_solicitacao where idsolicitacao = $idsolicitacao";
                $row = mysqli_fetch_array(execQuery($sql));
                $situacao = $row['situacao'];

                //se a situação for aberta (não houve tramitação), da o recebimento inicial da solicitação
                if ($situacao == "A")
                {
                    $sql="UPDATE lda_solicitacao SET
                            datarecebimentosolicitacao = NOW(),
                            idusuariorecebimento = ".getSession("uid")."
                          WHERE idsolicitacao = $idsolicitacao";

                    if (!execQuery($sql))
                        //die($sql);
                        return "Erro no recebimento da solicitação";

                }
                else
                {

                    //verifica se já houve recebimento
                    $sql="select count(*) as tot from lda_movimentacao
                        where idmovimentacao = (select max(idmovimentacao) from lda_movimentacao where idsolicitacao = $idsolicitacao)
                                and datarecebimento is null";

                    $row = mysqli_fetch_array(execQuery($sql));

                    //se a ultima movimentação nao tiver sido recebida, executa o recebimento
                    if($row["tot"] > 0)
                    {

                        //verifica se o usuario é da unidade de destino
                        $sql="select count(*) as tot from lda_movimentacao
                            where idmovimentacao = (select max(idmovimentacao) from lda_movimentacao where idsolicitacao = $idsolicitacao)
                                and idsecretariadestino = ".getSession("idsecretaria");

                        $row = mysqli_fetch_array(execQuery($sql));

                        //se o ususario pertencer a unidade de destino, da o recebimento
                        if($row["tot"] > 0)
                        {
                            $sql="UPDATE lda_movimentacao SET
                                    datarecebimento = NOW(),
                                    idusuariorecebimento = ".getSession("uid")."
                                  WHERE idsolicitacao = $idsolicitacao
                                      and datarecebimento is null";

                            if (!execQuery($sql))
                                return "Erro no recebimento da solicitação";

                        }
                        else
                        {
                            return "Usuário não pertence a secretaria de destino";
                        }

                    }
                }

                return "";
        }

        //retorna se existe sic centralizador
        public static function existeSicCentralizador(){
            $sql = "select count(*) as tot from sis_secretaria where ativado = 1 and siccentral = 1";
            $rs = execQuery($sql);
            $row = mysqli_fetch_array($rs);
            return ($row['tot']>0);
        }

        //retorna consulta de movimentações da solicitação
        public static function getMovimentacao($idsolicitacao)
        {

            $sql = "select m.*, sOri.sigla as origem, sDes.sigla as destino, usrDes.nome as usuariorecebimento, usrOri.nome as usuarioenvio
                    from lda_movimentacao m
                    join sis_secretaria sOri on sOri.idsecretaria = m.idsecretariaorigem
                    join sis_secretaria sDes on sDes.idsecretaria = m.idsecretariadestino
                    join sis_usuario usrOri on usrOri.idusuario = m.idusuarioenvio
                    left join sis_usuario usrDes on usrDes.idusuario = m.idusuariorecebimento
                    where idsolicitacao=$idsolicitacao ";

            $sql .= " order by idmovimentacao"; //ordena

            return execQuery($sql);
        }

        //retorna consulta com os recursos da solicitação
        public static function getRecursos($idsolicitacao)
        {

            $sql = "select sol.*, tip.nome as tiposolicitacao
                    from lda_solicitacao sol, lda_tiposolicitacao tip
                    where sol.idtiposolicitacao = tip.idtiposolicitacao
                            and sol.idsolicitacaoorigem=$idsolicitacao
                     order by sol.idsolicitacao";

            return execQuery($sql);
        }

        //retorna se ainda cabe recurso para a solicitação
        public static function getPodeRecurso($idsolicitacao, $idsolicitacaoorigem)
        {
            //recupera o id do tipo de solicitação seguinte a atual
            $sql = "select idtiposolicitacao_seguinte
                    from lda_tiposolicitacao
                    where idtiposolicitacao = (select idtiposolicitacao
                                               from lda_solicitacao
                                               where idsolicitacao= $idsolicitacao)";

            $result = execQuery($sql);
            $row = mysqli_fetch_array($result);
            $idtiposolicitacaoseguinte = $row['idtiposolicitacao_seguinte'];

            //se não houver solicitação seguinte, é a de ultima instancia, portanto não cabe mais recurso
            if(empty($idtiposolicitacaoseguinte))
                return false;
            else
            {
                //verifica se existe recurso pedido para a solicitação passada
                $sql = "select *
                        from lda_solicitacao
                        where idsolicitacaoorigem = $idsolicitacaoorigem
                            and idtiposolicitacao = $idtiposolicitacaoseguinte
                        ";

                //se nao encontrar recurso, pode solicitar
                return (mysqli_num_rows(execQuery($sql))==0);
            }

        }

	static public function finaliza($idsolicitacao,$tiporesposta,$resposta, $arquivos)
	{
                if(empty($tiporesposta))
                {
                    return "O campo Tipo de Resposta deve ser preenchido";
                }

                if(empty($resposta))
                {
                    return "O campo Observação deve ser preenchido";
                }

		$sql="UPDATE lda_solicitacao SET
			situacao = '$tiporesposta',
                        idusuarioresposta = ".getSession("uid").",
                        dataresposta = NOW(),
                        resposta = '".str_replace("'","\'",$resposta)."',
                        idsecretariaresposta = ".getSession("idsecretaria")."
                      WHERE idsolicitacao = '$idsolicitacao'";

                $con = db_open_trans();
                $all_query_ok=true;

                $erro="";
                if (!$con->query($sql))
                {
                    $erro = "Ocorreu um erro ao atualizar solicitação";
                    $all_query_ok = false;
                }
                else
                {
                    if(!empty($arquivos))
                    {
                            $numeroCampos = 3; //numero de campos de arquivo
                            $dir = getDiretorio("lda")."/";

                            for($i=0;$i<$numeroCampos;$i++)
                            {

                                    if(!empty($arquivos["tmp_name"][$i]))
                                    {
                                            //insere arquivos
                                            $sql="INSERT INTO lda_anexo (
                                                                    idsolicitacao,
                                                                    nome,
                                                                    idusuarioinclusao,
                                                                    datainclusao
                                                            ) VALUES (
                                                                    '$idsolicitacao',
                                                                    null,
                                                                    ".getSession("uid").",
                                                                    NOW()
                                                            )";

                                            if ($con->query($sql))
                                            {
                                                    $idarquivo = $con->insert_id;
													$ext = getExtensaoArquivo($arquivos["name"][$i]);

                                                    $fullArquivo = "lda_".$idsolicitacao."_file_".$idarquivo.".".$ext;

                                                    if (!@move_uploaded_file($arquivos["tmp_name"][$i], $dir.$fullArquivo))
                                                    {
                                                            $erro = "Ocorreu um erro ao efetuar o upload do arquivo ".$dir.$fullArquivo."; nome:".$arquivos["tmp_name"][$i];
                                                            $all_query_ok=false;
                                                            break;
                                                    }
                                                    else
                                                    {
                                                            $sql = "update lda_anexo set nome = '$fullArquivo' where idanexo = $idarquivo";
                                                            if (!$con->query($sql))
                                                            {
                                                                    $erro = "Ocorreu um erro ao efetuar atualizar nome do arquivo";
                                                                    $all_query_ok=false;
                                                                    break;
                                                            }
                                                    }
                                            }
                                            else
                                            {
                                                    $erro = "Erro ao inserir arquivo";
                                                    $all_query_ok = false;
                                                    break;
                                            }
                                    }
                            }
                    }
                }

		if (!$all_query_ok)
                {
                    $con->rollback();
                    return $erro;
                }
                else
                {
                    $con->commit();

                    //envia email de aviso de cadastro de solicitação ao solicitante
                    Solicitacao::enviaEmailSolicitante($idsolicitacao,"R");

                    return "";
                }

	}

	static public function prorrogar($idsolicitacao,$motivo)
	{
                if(empty($motivo))
                {
                    return "O campo motivo deve ser preenchido";
                }

                $configuracao = Solicitacao::getParametrosConfiguracao();

                $sql = "select t.instancia from lda_solicitacao s, lda_tiposolicitacao t
                        where s.idtiposolicitacao = t.idtiposolicitacao
                               and s.idsolicitacao = $idsolicitacao";
                $rs = execQuery($sql);
                $row = mysqli_fetch_array($rs);

                //se não for prorrogação de primeira instancia
                if($row['instancia'] != "I")
                    $prazoresposta = $configuracao['qtdeprorrogacaorecurso'];
                else
                    $prazoresposta = $configuracao['qtdprorrogacaoresposta'];

                $sql="UPDATE lda_solicitacao SET
                        idusuarioprorrogacao = ".getSession("uid").",
                        dataprorrogacao = NOW(),
                        motivoprorrogacao = '".str_replace("'","\'",$motivo)."',
                        dataprevisaoresposta = date_add(dataprevisaoresposta, interval $prazoresposta DAY )
                      WHERE idsolicitacao = '$idsolicitacao'";

		if (!execQuery($sql))
                {
                    return "Erro na prorrogação da solicitação";
                }
                else
                {
                    //envia email de aviso de cadastro de solicitação ao solicitante
                    Solicitacao::enviaEmailSolicitante($idsolicitacao,"P");

                }

		return "";
	}

} //fecha a classe

?>


text:
package com.framegen.api.response;

public class NumberFramesResponseVO extends ResponseVO {

	private static final long serialVersionUID = -1812148720394575912L;

	private Integer numberOfFrames;

	public Integer getNumberOfFrames() {
		return numberOfFrames;
	}

	public void setNumberOfFrames(Integer numberOfFrames) {
		this.numberOfFrames = numberOfFrames;
	}

}

redpajama_set_name: RedPajamaGithub


text:
<?php

     $altera->setNome($Nome);
     $altera->setEmpresa($Empresa);
     $altera->setLogin($Login);
     $altera->setDirecao($Direcao);
     $altera->setEdificio($Edificio);
     $altera->setPiso($Piso);
     $altera->setPosicao($posicao);
     $altera->setContacto($Contacto);
     $altera->setEmail($Email);

     ///

     $altera->setNome_w($Nome_w);
     $altera->setTipo($Tipo);
     $altera->setMarca($Marca);
     $altera->setModelo($Modelo);
     $altera->setDisco($Disco);
     $altera->setMemoria($Memoria);
     $altera->setProcessador($Processador);
     $altera->setSN($Serial_Number);
     $altera->setPN($Port_Number);
     $altera->setMarc_Moni($Marca_Monitor);
     $altera->setModel_Moni($Modelo_Monitor);
     $altera->setSN_Moni($SN_Monitor);
     $altera->setMac_Eth($Mac_Ethernet);
     $altera->setMac_Wirells($Mac_Wirelles);
     $altera->setMac_bluth($Mac_bl);

     ///

     $altera->setNome_s($Nome_s);
     $altera->setConfig_OutLook($Outlook);
     $altera->setConfig_Impressora($Impressora);
     $altera->setConfig_Antivir($Antivirus);
     $altera->setActual_Cadastr($Actualizar_Cadastro);
     $altera->setAd_especific($Mv_Ad);
     $altera->setPonto_Red_Voip($Rede);
     $altera->setPonto_Red_Voip($Rede_v);
     $altera->setPorta_Switch($pw);
     $altera->setSoft_Add($soft);

     /////////////////

     $altera->setPass_Bios($Passwordbios);
     $altera->setDesat_Bios($Desat_bios);
     $altera->setVerific_Devices($Verific_devices);
     $altera->setMuda_Drive($Drive);
     $altera->setAd_Dom_Zap($dom_Zap);
     $altera->setValid_Zap_Admin($Valid_zap_Admin);

     $altera->setNome_t($Nome_t);
     $altera->setData($Data);
     $altera->setUsuario_entreg($Entregue);
     $altera->setData_entrega($Data_entrega);
     $altera->setComentarios($Comentarios);
?>


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.workloads.models;

import com.azure.core.util.ExpandableStringEnum;
import com.fasterxml.jackson.annotation.JsonCreator;
import java.util.Collection;

/** Defines values for SapDeploymentType. */
public final class SapDeploymentType extends ExpandableStringEnum<SapDeploymentType> {
    /** Static value SingleServer for SapDeploymentType. */
    public static final SapDeploymentType SINGLE_SERVER = fromString("SingleServer");

    /** Static value ThreeTier for SapDeploymentType. */
    public static final SapDeploymentType THREE_TIER = fromString("ThreeTier");

    /**
     * Creates or finds a SapDeploymentType from its string representation.
     *
     * @param name a name to look for.
     * @return the corresponding SapDeploymentType.
     */
    @JsonCreator
    public static SapDeploymentType fromString(String name) {
        return fromString(name, SapDeploymentType.class);
    }

    /**
     * Gets known SapDeploymentType values.
     *
     * @return known SapDeploymentType values.
     */
    public static Collection<SapDeploymentType> values() {
        return values(SapDeploymentType.class);
    }
}


text:
package org.gradle.test.performance.mediummonolithicjavaproject.p381;

import org.junit.Test;
import static org.junit.Assert.*;

public class Test7635 {
    Production7635 objectUnderTest = new Production7635();

    @Test
    public void testProperty0() {
        Production7626 value = new Production7626();
        objectUnderTest.setProperty0(value);
        assertEquals(value, objectUnderTest.getProperty0());
    }

    @Test
    public void testProperty1() {
        Production7630 value = new Production7630();
        objectUnderTest.setProperty1(value);
        assertEquals(value, objectUnderTest.getProperty1());
    }

    @Test
    public void testProperty2() {
        Production7634 value = new Production7634();
        objectUnderTest.setProperty2(value);
        assertEquals(value, objectUnderTest.getProperty2());
    }

    @Test
    public void testProperty3() {
        String value = "value";
        objectUnderTest.setProperty3(value);
        assertEquals(value, objectUnderTest.getProperty3());
    }

    @Test
    public void testProperty4() {
        String value = "value";
        objectUnderTest.setProperty4(value);
        assertEquals(value, objectUnderTest.getProperty4());
    }

    @Test
    public void testProperty5() {
        String value = "value";
        objectUnderTest.setProperty5(value);
        assertEquals(value, objectUnderTest.getProperty5());
    }

    @Test
    public void testProperty6() {
        String value = "value";
        objectUnderTest.setProperty6(value);
        assertEquals(value, objectUnderTest.getProperty6());
    }

    @Test
    public void testProperty7() {
        String value = "value";
        objectUnderTest.setProperty7(value);
        assertEquals(value, objectUnderTest.getProperty7());
    }

    @Test
    public void testProperty8() {
        String value = "value";
        objectUnderTest.setProperty8(value);
        assertEquals(value, objectUnderTest.getProperty8());
    }

    @Test
    public void testProperty9() {
        String value = "value";
        objectUnderTest.setProperty9(value);
        assertEquals(value, objectUnderTest.getProperty9());
    }

}


text:
layout: page
title: Registration
registration_open: no
form_api_token: e1a81447f8d57fec2ce2afa7e88904a2
---

{% if page.registration_open %}

  Registration is open.

{% else %}

  Registration is closed.

{% endif %}

{% if page.registration_open %}

You can use this form to register for the GAP Days.

If you any questions
regarding registration or the school + coding sprint, feel free to
contact us via email.

<form action="http://getsimpleform.com/messages?form_api_token={{page.form_api_token}}" method="post">

    Name *

  <input type="text" size="60" maxlength="80" name="name" autofocus required />

    Gender *

  <input type="Gender" size="60" maxlength="80" name="Gender" required />

    Email *

  <input type="email" size="60" maxlength="80" name="email" required />

    Affiliation

    Please enter the name of your home university, institute etc., if any.

  <input type="text" size="60" maxlength="80" name="affiliation" />

    Arrival date *

    Please select the day of arrival.

  <select name="arrival.date" id="arrival_date" required>
    <option value="Saturday 12th or before">Saturday 12th or before</option>
    <option value="Sunday 13th" selected="selected">Sunday 13th</option>
    <option value="Monday 14th">Monday 14th</option>
    <option value="Tuesday 15th">Tuesday 15th</option>
    <option value="Wednesday 16th">Wednesday 16th</option>
    <option value="Thursday 17th">Thursday 17th</option>
    <option value="Friday 18th">Friday 18th</option>
  </select>

    Departure date *

    Please select the last day you will attend the school + coding sprint.

  <select name="departure.date" id="departure_date" required>
    <option value="Monday 14th">Monday 14th</option>
    <option value="Tuesday 15th">Tuesday 15th</option>
    <option value="Wednesday 16th">Wednesday 16th</option>
    <option value="Thursday 17th">Thursday 17th</option>
    <option value="Friday 18th" selected="selected">Friday 18th</option>
    <option value="Saturday 19th">Saturday 19th</option>
    <option value="Sunday 20th">Sunday 20th</option>
    <option value="Monday 21st">Monday 21st</option>
    <option value="Tuesday 22nd">Tuesday 22nd</option>
    <option value="Wednesday 23rd">Wednesday 23rd</option>
    <option value="Thursday 24th or later">Thursday 24th or later</option>
  </select>

    Accommodation/Funding?

    Accommodation: We have reserved rooms in Scandic
    Bakklandet
    at special university rates (single room 990 NOK per night, double room
    595 NOK per person per night), and we expect as a default option that participants
    share double rooms.  So please indicate under
    Wishes if (i) you have any other
    participant you would like to share a double room with, or
    (ii) you want us to find a roommate for you, or
    (iii) you want a single room, or
    (iv) if you arrange your own accommodation.

    Funding:
    We have some limited funding available to cover travel and hotel
    expenses. We limit our support for the accommodation to the GAP
    school September 13-19th. In addition, the maximum of support
    towards accommodation is the rate for one person in a double
    room. If you need support in order to attend the workshop, please
    enter an estimate of your expected travel expenses in the input
    box below and register before the 1st of August.

  <input type="text" size="60" maxlength="180" name="funding" />

    Wishes?

    Here you can enter (i) your requests for
    acccommodation, (ii) further details concerning
    support, (iii) any comments, questions or wishes
    regarding the school.

  <textarea name="comments" rows="10" cols="60"></textarea>

<input type='hidden' name='redirect_to' value='{{ site.url }}{{ site.baseurl }}/thank-you' />

  <input type="submit" value="Register!" />

</form>
{% endif %}


text:
package fr.insalyon.citi.golo.runtime;

import gololang.FunctionReference;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class TypeMatching {

  private static final Map<Class, Class> PRIMITIVE_MAP = new HashMap<Class, Class>() {
    {
      put(byte.class, Byte.class);
      put(short.class, Short.class);
      put(char.class, Character.class);
      put(int.class, Integer.class);
      put(long.class, Long.class);
      put(float.class, Float.class);
      put(double.class, Double.class);
      put(boolean.class, Boolean.class);
    }
  };

  public static boolean haveEnoughArgumentsForVarargs(Object[] arguments, Constructor constructor, Class<?>[] parameterTypes) {
    return constructor.isVarArgs() && (arguments.length >= parameterTypes.length);
  }

  public static boolean haveEnoughArgumentsForVarargs(Object[] arguments, Method method, Class<?>[] parameterTypes) {
    return method.isVarArgs() && (arguments.length >= (parameterTypes.length - 1));
  }

  public static boolean haveSameNumberOfArguments(Object[] arguments, Class<?>[] parameterTypes) {
    return parameterTypes.length == arguments.length;
  }

  public static boolean canAssign(Class<?>[] types, Object[] arguments, boolean varArgs) {
    if (types.length == 0 || arguments.length == 0) {
      return true;
    }
    for (int i = 0; i < types.length - 1; i++) {
      if (!valueAndTypeMatch(types[i], arguments[i])) {
        return false;
      }
    }
    final int last = types.length - 1;
    if (varArgs && arguments.length == last) {
      return true;
    }
    if (last >= arguments.length) {
      return false;
    }
    if (varArgs && !(arguments[last] instanceof Object[])) {
      return valueAndTypeMatch(types[last].getComponentType(), arguments[last]);
    }
    return valueAndTypeMatch(types[last], arguments[last]);
  }

  public static boolean valueAndTypeMatch(Class<?> type, Object value) {
    return primitiveCompatible(type, value) || (type.isInstance(value) || value == null || samAssignment(type, value) || functionalInterfaceAssignment(type, value));
  }

  private static boolean functionalInterfaceAssignment(Class<?> type, Object value) {
    return (value instanceof FunctionReference) && isFunctionalInterface(type);
  }

  public static boolean samAssignment(Class<?> type, Object value) {
    return (value instanceof FunctionReference) && isSAM(type);
  }

  public static boolean isSAM(Class<?> type) {
    return type.isInterface() && (type.getMethods().length == 1);
  }

  public static boolean isFunctionalInterface(Class<?> type) {
    return type.isAnnotationPresent(FunctionalInterface.class);
  }

  public static boolean primitiveCompatible(Class<?> type, Object value) {
    if (!type.isPrimitive() || value == null) {
      return false;
    }
    return PRIMITIVE_MAP.get(type) == value.getClass();
  }

  public static boolean isLastArgumentAnArray(int index, Object[] args) {
    return index > 0 && args.length == index && args[index - 1] instanceof Object[];
  }
}


text:
extern "C" {
#include "ChessBoard.h"
}

// test validMoves for left Black knight on a fresh board
TEST(ChessBoard_validMoves, leftBlackKnightWithFreshBoard)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {" r ","(n)"," b "," q "," k "," b "," n "," r "},
                                                      {" p "," p "," p "," p "," p "," p "," p "," p "},
                                                      {"[ ]","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {" P "," P "," P "," P "," P "," P "," P "," P "},
                                                      {" R "," N "," B "," Q "," K "," B "," N "," R "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on a fresh board
TEST(ChessBoard_validMoves, rightBlackKnightWithFreshBoard)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {" r "," n "," b "," q "," k "," b ","(n)"," r "},
                                                      {" p "," p "," p "," p "," p "," p "," p "," p "},
                                                      {"   ","   ","   ","   ","   ","[ ]","   ","[ ]"},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {" P "," P "," P "," P "," P "," P "," P "," P "},
                                                      {" R "," N "," B "," Q "," K "," B "," N "," R "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - in middle
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardInMiddle)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","[ ]","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","   ","(n)","   ","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","[ ]","   ","[ ]","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - left side
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardLeftSide)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - right side
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardRightSide)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[ ]","   "},
                                                      {"   ","   ","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"},
                                                      {"   ","   ","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[ ]","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - top left corner
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardTopLeftCorner)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - top right corner
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardTopRightCorner)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"},
                                                      {"   ","   ","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[ ]","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - bottom left corner
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardBottomLeftCorner)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","[ ]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - bottom right corner
TEST(ChessBoard_validMoves, BlackKnightWithEmptyBoardBottomRightCorner)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[ ]","   "},
                                                      {"   ","   ","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - in middle - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightdInMiddleVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","[B]","   ","   ","   "},
                                                      {"   "," q ","   ","   ","   ","[K]","   ","   "},
                                                      {"   ","   ","   ","(n)","   ","   ","   ","   "},
                                                      {"   ","[P]","   ","   ","   ","[ ]","   ","   "},
                                                      {"   ","   "," k ","   "," b ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - left side - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightLeftSideVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   "," k ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[ ]","   ","   ","   ","   ","   "},
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","[P]","   ","   ","   ","   ","   "},
                                                      {"   ","[Q]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - right side - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightRightSideVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[ ]","   "},
                                                      {"   ","   ","   ","   ","   ","[N]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"},
                                                      {"   ","   ","   ","   ","   "," n ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[K]","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - top left corner - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightTopLeftCornerVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   "," b ","   ","   ","   ","   ","   "},
                                                      {"   ","[K]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - top right corner - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightTopRightCornerVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"},
                                                      {"   ","   ","   ","   ","   ","[Q]","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   "," q ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - bottom left corner - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightBottomLeftCornerVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","[B]","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   "," b ","   ","   ","   ","   ","   "},
                                                      {"(n)","   ","   ","   ","   ","   ","   ","   "}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}

// test validMoves for right Black knight on an empty board - bottom right corner - various pieces on board
TEST(ChessBoard_validMoves, BlackKnightBottomRightCornerVariousPieces)
{
    enum ChessBoardRank rank;               // rank of the piece we're watching
    enum ChessBoardFile file;               // file of the piece we're watching
    struct ChessBoard board;
    char expectedValidLocations[65];        // what we expect the valid moves to be
    int numberOfExpectedLocations;          // expected number of valid moves
    char validLocations[65];                // the valid moves that are determined

    numberOfExpectedLocations = parseTestingBoard((char [][8][8])
                                                  {
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","[Q]","   "},
                                                      {"   ","   ","   ","   ","   "," q ","   ","   "},
                                                      {"   ","   ","   ","   ","   ","   ","   ","(n)"}
                                                  }, &board, expectedValidLocations, &file, &rank, true);

    // perform SUT and check that it returned the proper number of valid locations
    ASSERT_EQ(numberOfExpectedLocations, validMoves(&board, file, rank, VALID_MOVE, validLocations));

    // compare the evaluated valid locations
    ASSERT_STREQ(expectedValidLocations, validLocations);
}


text: Pcb runningPcb = NULL;


text:
using System.Xml.Linq;

namespace Moju.WeChatHelper
{
   public class WeChatImageResult:WeChatResult
    {
       public string MediaId { get; set; }
       public WeChatImageResult()
       {
           this.MsgType = SMessageType.Image;
       }
       protected override void SubXml(XElement xml)
       {
           xml.Add(new XElement("Image",
               new XElement("MediaId",
                   new XCData(MediaId))));
       }
    }
}


text:
module VagrantPlugins
  module Beaker
    module Provider
      module VSphereActions
        class SafeShutdown
          def initialize( app, env )
            @app = app
            @logger = Log4r::Logger.new( 'vagrant_plugins::beaker::provider::vsphere_actions::safe_shutdown' )
          end

          def call( env )
            config     = env[:machine].provider_config
            vsphere    = env[:vsphere][:connection]
            connection = vsphere.instance_variable_get :@connection
            datacenter = connection.serviceInstance.find_datacenter

            metadata_file = File.join( env[:machine].data_dir.to_s, 'metadata.json' )

            if File.exists? metadata_file
              metadata    = JSON.parse( File.read( metadata_file ) )
              vm          = datacenter.find_vm( config.target_folder + '/' + metadata['machine_name'] )

              if vm.summary.runtime.powerState == 'poweredOn'
                if vm.summary.guest.toolsRunningStatus == 'guestToolsRunning'
                  env[:machine].ui.report_progress 0, 100
                  vm.ShutdownGuest

                  poll connection, vm, 'summary.runtime.powerState' do |i|
                    env[:machine].ui.clear_line
                    env[:machine].ui.report_progress i, 100

                    vm.summary.runtime.powerState == 'poweredOff'
                  end
                end
              end

            else
              raise 'VM metadata was deleted out from under Vagrant'
            end

            @app.call( env )
          end

          def poll( connection, vm, *properties, &block )
            filter = connection.propertyCollector.CreateFilter(
              spec: {
                propSet: [{
                           type:    'VirtualMachine',
                           all:      false,
                           pathSet:  properties
                         }],
                objectSet: [{ obj: vm }]
              },
              partialUpdates: false
            )

            # yeah, it's a really long name, but not as long as it took my
            # simple brain to figure out what the hell it was
            last_point_in_update_stream = ''
            polling = true

            # block until our tasks have succeeded or errored
            loop do
              result = connection.propertyCollector.WaitForUpdates(
                :version => last_point_in_update_stream
              )

              last_point_in_update_stream = result.version

              break if block.call

            end

            filter.DestroyPropertyFilter
          end
        end
      end
    end
  end
end


text:
from yowsup.layers import YowProtocolLayerTest
from yowsup.layers.protocol_chatstate import YowChatstateProtocolLayer
from yowsup.layers.protocol_chatstate.protocolentities import IncomingChatstateProtocolEntity, OutgoingChatstateProtocolEntity

class YowChatStateProtocolLayerTest(YowProtocolLayerTest, YowChatstateProtocolLayer):
    def setUp(self):
        YowChatstateProtocolLayer.__init__(self)

    def test_send(self):
        entity = OutgoingChatstateProtocolEntity(OutgoingChatstateProtocolEntity.STATE_PAUSED, "jid@s.whatsapp.net")
        self.assertSent(entity)

    def test_receive(self):
        entity = IncomingChatstateProtocolEntity(IncomingChatstateProtocolEntity.STATE_TYPING, "jid@s.whatsapp.net")
        self.assertReceived(entity)


text:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PausedScript : MonoBehaviour {

    public bool paused;
    GameObject pausedObject;

	// Use this for initialization
	void Start () {

        paused = false;
        //pausedObject = GameObject.FindGameObjectWithTag("PausedScreen)");
        hidePaused();

	}

    // Update is called once per frame
    void Update() {

        if (Input.GetKeyDown(KeyCode.P))
        {
            paused = !paused;
        }

        if (paused)
        {
            Time.timeScale = 0;
            //pausedObject.SetActive(true);
        }
        if (!paused)
        {
            hidePaused();
            Time.timeScale = 1;
        }

    }
    public void hidePaused()
    {
        //pausedObject.SetActive(false);
    }

}


text:
node_space
==========

Simple space trading game.


text:
package org.asciidoctor.diagram.ditaa;

import org.asciidoctor.diagram.*;
import org.stathissideris.ascii2image.core.CommandLineConverter;
import org.stathissideris.ascii2image.core.ConversionOptions;
import org.stathissideris.ascii2image.graphics.BitmapRenderer;
import org.stathissideris.ascii2image.text.TextGrid;

import javax.imageio.ImageIO;
import javax.imageio.stream.MemoryCacheImageOutputStream;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

public class Ditaa implements DiagramGenerator
{
    public static final MimeType DEFAULT_OUTPUT_FORMAT = MimeType.PNG;
    public static final MimeType DEFAULT_CONTENT_TYPE = MimeType.TEXT_PLAIN_UTF8;
    public static final String DEFAULT_CHARSET = "UTF-8";

    @Override
    public String getName()
    {
        return "ditaa";
    }

    @Override
    public ResponseData generate(Request request) throws IOException {
        MimeType format = request.headers.getValue(HTTPHeader.ACCEPT);
        if (format == null) {
            format = DEFAULT_OUTPUT_FORMAT;
        }

        if (!format.equals(MimeType.PNG) && !format.equals(MimeType.SVG)) {
            throw new IOException("Unsupported output format: " + format);
        }

        MimeType contentType = request.headers.getValue(HTTPHeader.CONTENT_TYPE);
        if (contentType == null) {
            contentType = DEFAULT_CONTENT_TYPE;
        }

        String charset = contentType.parameters.get("charset");
        if (charset == null) {
            charset = DEFAULT_CHARSET;
        }

        java.util.List<String> options = new ArrayList();
        options.add("--encoding");
        options.add(charset);

        if (format.equals(MimeType.SVG)) {
            options.add("--svg");
        }

        ConversionOptions conversionOptions;

        String optionString = request.headers.getValue(HTTPHeader.OPTIONS);
        if (optionString != null) {
            options.addAll(Arrays.asList(optionString.split(" ")));
        }

        ByteArrayOutputStream output = new ByteArrayOutputStream();
        CommandLineConverter.convert(
                options.toArray(new String[0]),
                new ByteArrayInputStream(request.data),
                output
        );
        output.close();

        return new ResponseData(
                format,
                output.toByteArray()
        );
    }
}


text:
Ambiente da Aula de LP3 configurado

1º Passo :
	\LP3---Ambiente-Configurado\apache-tomcat-8.0.24\bin\startup

2º Passo :
	\LP3---Ambiente-Configurado\db-derby-10.10.2.0-bin\bin\startNetworkServer

3º Passo :
	\LP3---Ambiente-Configurado\squirrelsql-3.7-optional\squirrel-sql

4º Passo :
	Acessar http://localhost:8080/
	Login: AdminTomcat
	Senha: AdminTomcat

5º Passo :
	Dar deploy no .war da aplicação(\LP3---Ambiente-Configurado\appLp3\dist\appLp3.war)

6º Passo :
	Ver como tudo funciona e Correr pro abraço :)

*7º Passo(Opcional):
	Caso encontre algum tipo de problema ao rodar JSTL no Tomcat fornecido, rode o projeto no Glassfish do netbeans, e o banco á parte

(Ambiente preparado para a aula de LP3 LAB - Prof. Fabio Kawaoka Takase 4J11 - MACKENZIE - 2016)