TEST_F(PacksTests, test_check_version) {
  auto fpack = Pack("foobar", getPackWithDiscovery());
  EXPECT_TRUE(fpack.checkVersion());

  auto zpack = Pack("foobaz", getPackWithFakeVersion());
  EXPECT_FALSE(zpack.checkVersion());
}

void MpHostSetupUi::initWindow() {
    window->SetStyle(Style::Fullscreen);
    window->SetRequisition(Vector2f((float)ct::WindowWidth, (float)ct::WindowHeight));

    mainBox = Box::Create(Box::Orientation::VERTICAL, 5);
    auto closeButton = Button::Create("Close");
    closeButton->GetSignal(Widget::OnLeftClick).Connect(backAction);
    mainBox->Pack(createAlignment(closeButton, Vector2f(0.0f, 0.0f), Vector2f(1.0f, 0.0f)));

    auto nameBox = Box::Create(Box::Orientation::HORIZONTAL, 5);
    nameEntry = Entry::Create("Player 1");
    nameEntry->SetMaximumLength(10);
    nameEntry->SetRequisition(Vector2f(ct::WindowWidth * 0.1f, 0.0f));
    auto createButton = Button::Create("Create");
    createButton->GetSignal(Widget::OnLeftClick).Connect(bind(&MpHostSetupUi::triggerCreateServer, this));

    nameBox->Pack(nameEntry, true, true);
    nameBox->Pack(createButton, true, true);

    nameFrame = Frame::Create("Your name:");
    nameFrame->Add(nameBox);
    nameFrame->SetRequisition(Vector2f(0.0f, ct::WindowHeight * 0.1f));
    mainBox->Pack(createAlignment(nameFrame, Vector2f(0.5f, 0.01f), Vector2f(1.0f, 0.0f)));

    window->Add(createAlignment(mainBox, Vector2f(0.5f, 0.5f), Vector2f(0.9f, 0.9f)));
}

void ExteriorNeighbor::Pack(
	const GridData4D & data
) {
	// Model grid
	const Grid & grid = m_pConnect->GetGridPatch().GetGrid();

	// 3D Grid Data
	GridData3D data3D;

	// For state data exclude non-collacted data points
	if (data.GetDataType() == DataType_State) {
		// List of variable indices to send
		// - exclude variables which are not-collocated with this data structure
		for (int c = 0; c < data.GetComponents(); c++) {
			if (grid.GetVarLocation(c) != data.GetDataLocation()) {
				continue;
			}
			data.GetAsGridData3D(c, data3D);
			Pack(data3D);
		}

	// Send everything
	} else {
		for (int c = 0; c < data.GetComponents(); c++) {
			data.GetAsGridData3D(c, data3D);
			Pack(data3D);
		}
	}
}

void CustomWidget::Run() {
	// Create SFML's window.
	sf::RenderWindow render_window( sf::VideoMode( SCREEN_WIDTH, SCREEN_HEIGHT ), "Custom Widget" );

	// Create our custom widget.
	m_custom_widget = MyCustomWidget::Create( "Custom Text" );

	// Create a simple button and connect the click signal.
	auto button = sfg::Button::Create( "Button" );
	button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &CustomWidget::OnButtonClick, this ) );

	// Create a vertical box layouter with 5 pixels spacing and add our custom widget and button
	// and button to it.
	auto box = sfg::Box::Create( sfg::Box::Orientation::VERTICAL, 5.0f );
	box->Pack( m_custom_widget );
	box->Pack( button, false );

	// Create a window and add the box layouter to it. Also set the window's title.
	auto window = sfg::Window::Create();
	window->SetTitle( "Custom Widget" );
	window->Add( box );

	// Create a desktop and add the window to it.
	sfg::Desktop desktop;
	desktop.Add( window );

	// We're not using SFML to render anything in this program, so reset OpenGL
	// states. Otherwise we wouldn't see anything.
	render_window.resetGLStates();

	// Main loop!
	sf::Event event;
	sf::Clock clock;

	while( render_window.isOpen() ) {
		// Event processing.
		while( render_window.pollEvent( event ) ) {
			desktop.HandleEvent( event );

			// If window is about to be closed, leave program.
			if( event.type == sf::Event::Closed ) {
				render_window.close();
			}
		}

		// Update SFGUI with elapsed seconds since last call.
		desktop.Update( clock.restart().asSeconds() );

		// Rendering.
		render_window.clear();
		m_sfgui.Display( render_window );
		render_window.display();
	}
}

void IHM::packFile(File f_)
{
    auto box = sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 50.f);
    box->Pack( sfg::Label::Create( f_.getFilename() ), true, true );
    box->Pack( sfg::Label::Create( f_.getFilepath() ), true, true );
    auto button = sfg::Button::Create( L"Load" );
    //auto funct = std::bind( &IHM::OnLoadMusicBtnClick, f_.getFilename());
    auto funct = std::bind(&IHM::OnLoadMusicBtnClick,this, f_.getFilename());//need to try this
    button->GetSignal( sfg::Widget::OnLeftClick ).Connect( funct );
    box->Pack( button, false );
    _listFiles->Pack( box, false);

WindowCreateCharacter::WindowCreateCharacter()
{
	this->window = sfg::Window::Create();
	this->window->SetTitle("Create Character");
	this->window->SetStyle(sfg::Window::Style::TITLEBAR | sfg::Window::Style::SHADOW | sfg::Window::Style::BACKGROUND);

	auto vbox = sfg::Box::Create(sfg::Box::Orientation::VERTICAL, 5.f);
	auto lblCharacterName = sfg::Label::Create(L"Character Name:");
	lblCharacterName->SetAlignment(sf::Vector2f(0.f, 0.5f));
	vbox->Pack(lblCharacterName);
	this->tbCharacterName = sfg::Entry::Create();
	this->tbCharacterName->SetMaximumLength(32);
	this->tbCharacterName->SetRequisition(sf::Vector2f(200.f, 0.f));
	this->tbCharacterName->SetText(L"Player");
	vbox->Pack(this->tbCharacterName);
	auto lblClass = sfg::Label::Create(L"Class:");
	lblClass->SetAlignment(sf::Vector2f(0.f, 0.5f));
	vbox->Pack(lblClass);
	this->cbxCharacterClass = sfg::ComboBox::Create();
	this->cbxCharacterClass->AppendItem(L"General");
	this->cbxCharacterClass->SelectItem(0);
	vbox->Pack(this->cbxCharacterClass);
	vbox->Pack(sfg::Separator::Create());
	auto hbox = sfg::Box::Create(sfg::Box::Orientation::HORIZONTAL);
	this->btnCancel = sfg::Button::Create(L"Cancel");
	hbox->Pack(this->btnCancel);
	this->btnPlay = sfg::Button::Create(L"Start!");
	hbox->Pack(btnPlay);

	vbox->Pack(hbox);
	this->window->Add(vbox);
}

netBool UnreliableListener::Push(SerializerLess &_ser, const Peer& _peer)
{
	assert(m_stream != nullptr);

	Channel& channel = GetChannel(m_sendChannels, _peer);

	SerializerLess *back = channel.Back();

	// bundling
	if(channel.IsEmpty() || back->GetSize() + _ser.GetSize() > back->GetBufferSize())
	{
		SerializerLess ser(m_pool.GetSerializer());
		// prepare serializer
		ser.Write(m_stream->GetType());

		SerializerLess stream_ser(ser, m_stream->GetHeaderSize(), ser.GetBufferSize());
		stream_ser.Write(GetType());
		stream_ser.Close();

		ser.SetCursor(ser.GetCursor() + stream_ser.GetSize());
		ser.Close();
		channel.Push(ser);
	}

	return Pack(_ser, _peer);
}

	bool Pack(msg_buffer_t & msgbuf) const {
		int sz = msgbuf.max_size;
		bool ret = Pack(msgbuf.buffer, sz);
		if (!ret) return ret;
		msgbuf.valid_size = sz;
		return true;
	}

uint WBEvent::GetSerializationSize() const
{
	WBPackedEvent PackedEvent;
	Pack( PackedEvent );

	return PackedEvent.GetSize() + 4;
}

GlobalIDDataBase::NodeKey_t
GlobalIDDataBase::push(LayoutID_t layoutID, int context, GlobalID_t globalID)
{
  int ret = data_m.size();
  data_m.push_back(Pack(layoutID, context, globalID, nullNodeKey()));
  return ret;
}

void CDownloadFileCompletePacket::InitData(string strUrl, int64 nFileLength, string strHashValue)
{
    this->strUrl = strUrl;
    this->nFileLength = nFileLength;
    this->strHashValue = strHashValue;
    Pack();
};

bool Pointer::PackStay(Environment &env, const char *format, const ValueList &valListArg)
{
	size_t offset = _offset;
	if (!Pack(env, format, valListArg)) return false;
	_offset = offset;
	return true;
}

bool ScrollBox::SendKey(const SDL_keysym & key)
{
  if (!WidgetList::SendKey(key)) {
    int new_offset = offset;
    switch(key.sym)
    {
    case SDLK_PAGEUP:
      new_offset -= size.y;
      break;
    case SDLK_PAGEDOWN:
      new_offset += size.y;
      break;
    default:
      return false;
    }

    if (new_offset < 0)
      new_offset = 0;
    if (new_offset > GetMaxOffset())
      new_offset = GetMaxOffset();

    if (new_offset != offset) {
      offset = new_offset;
      Pack();
      NeedRedrawing();
    }
  }
  return true;
}

void ScrollBox::__Update(const Point2i & mousePosition,
                         const Point2i & /*lastMousePosition*/)
{
  // update position of items because of dragging
  if (HasScrollBar() && scroll_mode!=SCROLL_MODE_NONE) {
    int max_offset = GetMaxOffset();
    int new_offset = offset;

    if (scroll_mode == SCROLL_MODE_THUMB) {
      Point2i track_pos  = GetScrollTrackPos();
      int     height     = GetTrackHeight();

      new_offset = start_drag_offset +
                   ((mousePosition.y - start_drag_y) * (size.y+max_offset))/height;
    } else if (scroll_mode == SCROLL_MODE_DRAG) {
      // Act as if the scroll corresponds to bringing the starting point to the
      // current point
      new_offset = start_drag_offset + start_drag_y - mousePosition.y;
    }

    if (new_offset < 0)
      new_offset = 0;
    if (new_offset > max_offset)
      new_offset = max_offset;

    if (new_offset != offset) {
      offset = new_offset;
      Pack();
    }
  }
}

bool PokerMsgBase::ToStream(StreamWriter* pWriter)
{
	if (!pWriter->Write(&m_Size, sizeof(m_Size))) return false;
	if (!pWriter->Write(&m_Type, sizeof(m_Type))) return false;

	return Pack(pWriter);
}

 static SIZE_TYPE Pack
 (const SrcCont& src,
  TCoding src_coding,
  DstCont& dst,
  TCoding& dst_coding,
  TSeqPos length)
 {
     if ( src.empty()  ||  (length == 0) ) {
         return 0;
     }
     
     AdjustLength(src, src_coding, 0, length);
     // we allocate enough memory for ncbi4na coding
     // if the result will be ncbi2na coding we'll resize (see below)
     ResizeDst(dst, CSeqUtil::e_Ncbi4na, length);
     
     SIZE_TYPE res = Pack(&*src.begin(), length, src_coding, 
                          &*dst.begin(), dst_coding);
     if ( dst_coding == CSeqUtil::e_Ncbi2na ) {
         size_t new_size = res / 4;
         if ( (res % 4) != 0 ) {
             ++new_size;
         }
         dst.resize(new_size);
     }
     return res;
 }

int main (int argc, char * * argv)
{
	if (argc != 3)
	{
		printf("\nInvalid number of arguments\n");
		return EXIT_FAILURE;
	}

	char * in_file = argv[1];
	char * out_file = argv[2];
	
	int num_b; // number of boxes
	int num_n; // nubmer of nodes

	// arr is an array implementation of a binary tree
	// the root node is the node of index num_n
	Node * arr = Load_File(in_file, &num_b, &num_n);

	double x_tot = 0;
	double y_tot = 0;

	clock_t pack_t = clock();
	Coord * crd = Pack(arr, num_n, num_b, &x_tot, &y_tot);
	pack_t = clock() - pack_t;

	printf("\n\nElapsed Time:  %le\n\n", ((double) pack_t) / CLOCKS_PER_SEC);

	Save_File(out_file, arr, crd, num_b);

	free(arr);
	free(crd);

	return EXIT_SUCCESS;
}

void Smooth()
{
	int imember; 		/* current member 	*/
	int i, j, igene;	/* counters		*/
	int begin, end;		/* limit the operator 	*/
	static double *Vector_Aux;
	static int first=1;

	if (first)
	{
	        Vector_Aux = 
			(double *) calloc((unsigned) Genes, sizeof(double));
                if (Vector_Aux == NULL) 
				Error("Allocation failed for Vector_Aux");
		first = 0;
	}

/*
    For all the members of the current population 
*/
	if (verbose) 
		fprintf(stderr,"\nSubpopulation %d smoothing trial solutions\n", instance);

	for (imember = 0; imember < Popsize; imember++)
	{
        	Unpack(New[imember].Gene, Bitstring, Length);
                FloatRep(Bitstring, Vector, Genes);

		for (igene = 0, Vector_Aux[igene] = 0.; 
		     igene < NSOURCES + NRECEIVERS; 
		     igene++, Vector_Aux[igene] = 0.)
		{
			if (igene < NSOURCES)
			{
				/* no smooth of source statics */
				Vector_Aux[igene] = Vector[igene];
			}	
			else
			{
				i = to_filter[igene - NSOURCES][0];
				j = to_filter[igene - NSOURCES][1];

				if (to_filter[igene - NSOURCES][2] == 2)
					Vector_Aux[igene] = 
						(Vector[i] + Vector[j]) / 2.;
				else
					Vector_Aux[igene] =
						(Vector[i] + Vector[igene] + 
						 Vector[j]) / 3.;
			}
		}
/*
    Packing
*/
                StringRep(Vector_Aux, Bitstring, Genes);
                Pack(Bitstring, New[imember].Gene, Length);
		New[imember].Needs_evaluation = 1;
	}
}

void FileListBox::PopulateFileList(const std::string& path)
{
  new_path = path;
  if (path.compare(path.size()-1, sizeof(PATH_SEPARATOR), PATH_SEPARATOR))
    new_path += PATH_SEPARATOR;
  MSG_DEBUG("file", "Searching in %s\n", new_path.c_str());

  FolderSearch *f = OpenFolder(new_path);

  // Now that we have made use of new_path, it can be freed:
  // clearing the list is now possible
  Clear();

  if (f) {
    bool is_file = list_files;
    const char *name;

    while ((name = FolderSearchNext(f, is_file)) != NULL) {
      if (is_file) {
        // We have a file, check that it validates the list
        if (MatchFilter(name)) {
          std::string* filename = new std::string(new_path);
          *filename += name;
          MSG_DEBUG("file", "Adding file %s\n", name);
          AddLabelItem(false, ANSIToUTF8(new_path, name), filename, Font::FONT_MEDIUM);
        } else {
          MSG_DEBUG("file", "NOT adding file %s, invalid extension\n", name);
        }
      } else if (strcmp(name, ".")) {
        std::string* filename;
        if (!strcmp(name, "..")) {
          // Are we at the root?
          if (!strcmp(name, PATH_SEPARATOR))
            break;
          size_t pos = new_path.find_last_of(PATH_SEPARATOR, new_path.size()-2, sizeof(PATH_SEPARATOR));
          filename = new std::string(new_path.substr(0, pos+1));
        } else
          filename = new std::string(new_path);
        *filename += name;
        MSG_DEBUG("file", "Adding directory %s\n", name);
        AddLabelItem(false, std::string("[") + ANSIToUTF8(new_path, name) + "]", filename,
                     Font::FONT_MEDIUM, Font::FONT_NORMAL, c_yellow);
      } else
        MSG_DEBUG("file", "Rejecting %s\n", name);

      // Prepare again for searching files
      is_file = list_files;
    }

    CloseFolder(f);
    Pack();
    NeedRedrawing();
  } else {
    MSG_DEBUG("file", "Search failed?\n");
  }

  // Store last time to drop fast clicks
  last_time = SDL_GetTicks();
}

netBool UDPStream::Push(SerializerLess &_ser, const Peer& _peer)
{
	assert(m_isValid);

	Pack(_ser, _peer);

	return true;
}