Вместо того, чтобы пытаться проводить тестирование на существующем сервере, используйте систему сборки, чтобы запускать новый сервер для каждого сеанса огурца.
Если вы используете maven и пружинный ботинок, вы можете использовать spring-boot-maven-plugin:start
и spring-boot-maven-plugin:stop
в фазе integration-test
.
Для вставки данных в базу данных вы обычно используете ту же систему, что и для обновления своей базы данных в производственной среде. Если вы используете Liquibase, вы можете пометить сценарии для тестирования / производства, чтобы гарантировать, что ваши тестовые данные не попадут в производство.
Я собираюсь отправить свой собственный anser и проголосовать за любого, который помог мне достигнуть его, так как это - то, что я буду использовать в конце, и Вы все помогли мне сделать этот вывод. Комментарии приветствуются.
std::pair<value_type, value_type> GetDivisions(const value_type& from) const
{
if (m_divisions.empty())
throw 0; // Can't help you if we're empty.
std::vector<value_type>::const_iterator it =
std::lower_bound(m_divisions.begin(), m_divisions.end(), from);
if (it == m_divisions.end())
return std::make_pair(m_divisions.back(), m_divisions.back());
else if (it == m_divisions.begin())
return std::make_pair(m_divisions.front(), m_divisions.front());
else
return std::make_pair(*(it - 1), *(it));
}
Можно захватить оба значения (если они существуют) в одном вызове с equal_range (). Это возвращает станд.:: пара итераторов, с тем, чтобы сначала быть первым местоположением и второй являющийся последним местоположением, в которое Вы могли вставить значение, передала, не нарушая упорядочивание. Для строгого соответствования критериям необходимо было бы постепенно уменьшить итератор в первом после проверки, что это не было равно вектору, начинаются ().
Можно использовать lower_bound STL для получения, хотят Вас, хотят в нескольких строках кода. lower_bound использует двоичный поиск под капотом, таким образом, Ваше время выполнения является O (зарегистрируйте n).
double val = 45;
double lower, upper;
std::vector<double>::iterator it;
it = lower_bound(f.begin(), f.end(), val);
if (it == f.begin()) upper = *it; // no smaller value than val in vector
else if (it == f.end()) lower = *(it-1); // no bigger value than val in vector
else {
lower = *(it-1);
upper = *it;
}
Вы могли просто использовать двоичный поиск, который будет работать в O (журнал (n)).
Вот отрывок Lua (у меня нет времени, чтобы сделать это в C++, извините), который делает то, что Вы хотите, за исключением предельных условий (что Вы не определили так или иначе):
function search(value, list, first, last)
if not first then first = 1; last = #list end
if last - first < 2 then
return list[first], list[last]
end
local median = math.ceil(first + (last - first)/2)
if list[median] > value then
return search(value, list, first, median)
else
return search(value, list, median, last)
end
end
local list = {1,10,100,1000}
print(search(arg[1] + 0, list))
Это принимает значение для поиска из командной строки:
$ lua search.lua 10 # didn't know what to do in this case
10 100
$ lua search.lua 101
100 1000
$ lua search.lua 99
10 100
Что, если (в Вашем случае) d является меньше, чем первый элемент или больше, чем последнее? И как иметь дело с отрицательными величинами? Между прочим: гарантия, что Ваш "d" живет между первым и последним значением Вашего вектора, который можно сделать как этот:
// Your initializations
std::vector<double>::const_iterator sit = f.begin();
double upper, lower;
Вот остальное:
while ( *sit < d ) // if the element is still less than your d
++sit; // increase your iterator
upper = *sit; // here you get the upper value
lower = *(--sit); // and here your lower
Достаточно изящный?:/
Я записал бы что-то вроде этого, не протестировал, если это компилирует, но Вы получаете идею:
template <typename Iterator>
std::pair<Iterator, Iterator> find_best_pair(Iterator first, Iterator last, const typename Iterator::value_type & val)
{
std::pair<Iterator, Iterator> result(last, last);
typename Iterator::difference_type size = std::distance(first, last);
if (size == 2)
{
// if the container is of size 2, the answer is the two elements
result.first = first;
result.first = first;
++result.first;
}
else
{
// must be of at lease size 3
if (size > 2)
{
Iterator second = first;
++second;
Iterator prev_last = last;
--prev_last;
Iterator it(std::lower_bound(second, last, val));
if (it != last)
{
result.first = it;
result.second = it;
if (it != prev_last)
{
// if this is not the previous last
// then the answer is (it, it + 1)
++result.second;
}
else
{
// if this the previous last
// then the answer is (it - 1, it)
--result.first;
}
}
}
}
return result;
}
Вы могли сделать поиск в своем векторе для Вашего значения (который скажет Вам, где Ваше значение было бы то, если бы это было в векторе), и затем возвратите значение прежде и после того местоположения. Так поиск 45 сказал бы Вам, что это должно быть в index=1, и затем Вы возвратились бы 0 и 1 (в зависимости от Вашей реализации поиска, Вы или получите индекс меньшего значения или индекс большего значения, но это легко свериться с парой граничных условий). Это должно смочь работать в O (зарегистрируйте n), где n является числом элементов в Вашем векторе.
Я описал эту небольшую функцию, которая, кажется, соответствует более общему случаю, который Вы хотели. Я не протестировал его полностью, но я действительно писал немного (включенного) тестового кода.
#include <algorithm>
#include <iostream>
#include <vector>
template <class RandomAccessIt, class Container, class T>
std::pair<RandomAccessIt, RandomAccessIt> bracket_range(RandomAccessIt begin, RandomAccessIt end, Container& c, T val)
{
typename Container::iterator first;
typename Container::iterator second;
first = std::find(begin, end, val);
//Find the first value after this by iteration
second = first;
if (first == begin){ // Found the first element, so set this to end to indicate no lower values
first = end;
}
else if (first != end && first != begin) --first; //Set this to the first value before the found one, if the value was found
while (second != end && *second == val) ++second;
return std::make_pair(first,second);
}
int main(int argc, _TCHAR* argv[])
{
std::vector<int> values;
std::pair<std::vector<int>::iterator, std::vector<int>::iterator> vals;
for (int i = 1; i < 9; ++i) values.push_back(i);
for (int i = 0; i < 10; ++i){
vals = bracket_range(values.begin(), values.end(),values, i);
if (vals.first == values.end() && vals.second == values.end()){ // Not found at all
std::cout << i << " is not in the container." << std::endl;
}
else if (vals.first == values.end()){ // No value lower
std::cout << i << ": " << "None Lower," << *(vals.second) << std::endl;
}
else if (vals.second == values.end()) { // No value higher
std::cout << i << ": " << *(vals.first) << ", None Higher" << std::endl;
}
else{
std::cout << i << ": " << *(vals.first) << "," << *(vals.second) << std::endl;
}
}
return 0;
}
Если бы у Вас есть способность использовать некоторую другую структуру данных (не вектор), я предложил бы B-дерево. Если Вы, данные неизменны, я полагаю, что можно получить результат в постоянное время (логарифмическое время в худшем).