using namespace std;
#include<string>
#include<cmath>
#include<list>
#include<queue>
#include <map>
#include <unordered_map>
#include <set>
#define ll long long
#define ld long double
#define ull unsigned long long
#define ml map<ll,ll>
#define pb push_back
#define mp make_pair
#define ppl pair<ll,ll>
#define F first
#define S second
#define T third
#define Fo fourth
#define fio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)

#define fr(i,a,b) for(ll i=a;i<b;i++)
#define ffr(i,a,b) for(ll i=a;i>=b;i--)
#include<bits/stdc++.h>
#include<vector>
#define vl vector<ll>
#define PI 3.141592654
const ll N = 1e9 + 7;
const ll MAX = 1e15 + 7;
const ll P = 1e5 + 7;
const ll Q = 998244353;
#include<iterator>
#define EPSILON numeric_limits<double>::epsilon()
#include<tuple>


struct tup
{
	ll first, second, third;
};



// vector<vl> pr(N, vl(30, 0));

// vl vr;
// ml m;

// void precompute() {
//     fr(i, 2, N) {
//         if (!m[i]) {
//             // cout << i << " ";
//             vr.pb(i);
//             for (ll j = i * i; j < N; j += i)m[j] = 1;
//         }
//     }
// }

// vector<tup> pr(P, tup({0, 0, 0}));
vl pr(P, 0);

void prime() {
	// ll cnt = 0, ma = 0;
	pr[1] = 1;
	fr(i, 2, P) {
		if (pr[i] == 0) {
			// ll temp=0;
			// cnt++;
			// ma = max(i, ma);
			for (ll j = i * i; j <= P; j += i) {
				// pr[j].F = 1;
				pr[j] = 1;
				// temp++;
			}
			// cnt[i] = temp;
		}
		// pr[i].S = cnt;
		// pr[i].T = ma;
	}
}

ll gcd(ll a, ll b) {
	if (a == b)return a;
	if (a % b == 0)return b;
	if (b % a == 0)return a;
	if (b > a)return gcd(a, b % a);
	if (a > b)return gcd(a % b, b);
	return 0;
}

void show(ll a[], ll d) {
	if (d)fr(i, 0, d)cout << a[i] << " ";
}

void inp(ll a[], ll d) {
	fr(i, 0, d)cin >> a[i];
}

void Yesno(ll p) {
	if (p)cout << "Yes";
	else cout << "No";
}




// vl rightgreater(ll a[], ll n) {
// 	vl v;
// 	stack<ll> s;
// 	ffr(i, n - 1, 0) {
// 		if (s.size() == 0)v.pb(-1);
// 		else if (s.size() > 0 && s.top() > a[i])v.pb(s.top());
// 		else if (s.size() > 0 && s.top() <= a[i]) {
// 			while (s.size() > 0 && s.top() <= a[i])s.pop();
// 			if (s.size() == 0)v.pb(-1);
// 			else v.pb(s.top());
// 		}
// 		s.push(a[i]);
// 	}
// 	reverse(v.begin(), v.end());
// 	return v;
// }

// vl par, ran;


// ll findpar(ll x) {
// 	if (x == par[x])return x;

// 	return par[x] = findpar(par[x]);
// }

// void Union(ll x, ll y) {
// 	ll parx = findpar(x);
// 	ll pary = findpar(y)Snippet: map;;
// 	if (ran[parx] < ran[pary])par[parx] = pary;
// 	else if (ran[parx] > ran[pary])par[pary] = parx;
// 	else {par[parx] = pary; ran[pary]++;}
// }

// ld nthRoot(ll A, ll N) {
// 	ld xPre = rand() % 10, eps = 1e-3, delX = INT_MAX, xK;
// 	while (delX > eps) {
// 		xK = ((N - 1.0) * xPre + ((ld)A / pow(xPre, N - 1))) / (ld)N;
// 		cout << xK << " ";
// 		delX = abs(xK - xPre);
// 		xPre = xK;
// 	}
// 	cout << '\n';
// 	// cout << xK << " " << A << " " << N << '\n';
// 	return xK;
// }

// bool comp(tup &a, tup &b) {
// 	if (a.F != b.F)return a.F < b.F;
// 	else return a.S < b.S;
// }




// ll fact(ll n) {
// 	ll res = 1;
// 	fr (i, 2, n + 1) res = (res * i) % N;
// 	return res;
// }

// ll nCr(ll n, ll r) {
// 	return fact(n) / (fact(n - r) * fact(r));

// }

// ll nPr(ll n, ll r) {
// 	return ((fact(n) % N) / (fact(n - r) % N)) ;
// }


// ll power(ll a, ll b) {
// 	ll x = 1, y = a;
// 	while (b > 0) {
// 		if (b % 2 == 1) {
// 			x = (x * y);
// 			if (x > N) x %= N;
// 		}
// 		y = (y * y);
// 		if (y > N) y %= N;
// 		b /= 2;
// 	}
// 	return x;
// }


// ll InverseEuler(ll n) {
// 	return power(n, N - 2);
// }

// ll C(ll n, ll r) {
// 	return (fact(n) * ((InverseEuler(fact(r)) * InverseEuler(fact(n - r))) % N)) % N;
// }



// void rem_par(ll pnt) {
// 	visited[pnt] = true;
// 	for (auto it : v[pnt]) {
// 		if (!visited[it]) {
// 			grp[pnt].pb(it);
// 			rem_par(it);
// 		}
// 	}
// }


// ll powerLL(ll x, ll n) {
// 	ll result = 1;
// 	while (n) {
// 		if (n & 1)result = result * x % N;
// 		n = n / 2;
// 		x = x * x % N;
// 	}
// 	return result;
// }

// ll powerStrings(string sa, string sb) {
// 	ll a = 0, b = 0;
// 	fr (i, 0, sa.size())a = (a * 10 + (sa[i] - '0')) % N;
// 	fr (i, 0, sb.size())b = (b * 10 + (sb[i] - '0')) % (N - 1);
// 	return powerLL(a, b);
// }

// vl b;
// vector<vector<ppl>> v;
// vector<vl> v;
// vector<tup>val;
// vl depth;
// ll po;
// vector<string> ind;
// ll n, qu;
// // vl link, val;
// // vector<char>a;
// // // // string s;
// void binary_lifting(ll pnt, ll par, ll dep) {
// 	ancs[pnt][0] = par;
// 	depth[pnt] = dep;
// 	visited[pnt] = true;
// 	ll sp = log2(dep);
// 	fr(i, 1, sp + 1)ancs[pnt][i] = ancs[ancs[pnt][i - 1]][i - 1];
// 	for (auto it : v[pnt]) {
// 		if (!visited[it]) {
// 			dfs(it, pnt, dep + 1);
// 		}
// 	}
// }
// vl dis;



// ll lca(ll a, ll b) {
// 	if (depth[b] > depth[a])swap(a, b);
// 	ll dis = depth[a] - depth[b];
// 	while (dis > 0) {
// 		ll lo = log2(dis);
// 		a = ancs[a][lo];
// 		dis -= (1 << lo);
// 	}
// 	if (a == b)return a;
// 	ll ptr = log2(depth[b]);
// 	ffr(i, ptr, 0) {
// 		if (ancs[a][i] != ancs[b][i]) {
// 			a = ancs[a][i];
// 			b = ancs[b][i];
// 		}
// 	}
// 	return ancs[a][0];
// }


void solve() {
	ll n, a, b; cin >> n >> a >> b;
	string s; cin >> s;
	if (b >= 0)cout << (a + b)*n;
	else {
		ll one = 0, zero = 0, z = 0, o = 0;
		fr(i, 0, n) {
			if (s[i] == '0') {
				z++;
				if (o > 0)one++;
				o = 0;
			}
			else {
				o++;
				if (z > 0)zero++;
				z = 0;
			}
		}
		if (o > 0)one++;
		if (z > 0)zero++;
		cout << (a * n) + (min(one, zero) + 1)*b;
	}
}








int main() {
	fio;
#ifndef ONLINE_JUDGE
	// for getting input
	freopen("input.txt", "r", stdin);
	//for writing output
	freopen("jout.txt", "w", stdout);
#endif
	// prime();
	// precompute();
	ll t;
	if (0)
		t = 1;
	else
		cin >> t;
	fr(i, 0, t) {
		// cout << "Case #" << i + 1 << ": ";
		solve();
		// cout << endl;
		cout << '\n';
	}
	return 0;
}



